# Generated from Solidity.g4 by ANTLR 4.13.0
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO

def serializedATN():
    return [
        4,1,134,2503,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,
        7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,
        13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
        20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,
        26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,
        33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,
        39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,
        46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7,
        52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2,
        59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7,
        65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2,
        72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7,
        78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,2,
        85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,7,
        91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,
        98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,1,0,5,0,206,8,0,10,0,12,
        0,209,9,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,
        0,5,0,225,8,0,10,0,12,0,228,9,0,1,0,1,0,1,1,1,1,5,1,234,8,1,10,1,
        12,1,237,9,1,1,1,1,1,1,1,1,1,1,2,1,2,1,3,1,3,5,3,247,8,3,10,3,12,
        3,250,9,3,1,3,1,3,3,3,254,8,3,1,4,1,4,1,4,5,4,259,8,4,10,4,12,4,
        262,9,4,3,4,264,8,4,1,4,5,4,267,8,4,10,4,12,4,270,9,4,1,5,1,5,5,
        5,274,8,5,10,5,12,5,277,9,5,1,6,3,6,280,8,6,1,6,1,6,5,6,284,8,6,
        10,6,12,6,287,9,6,1,6,3,6,290,8,6,1,6,1,6,5,6,294,8,6,10,6,12,6,
        297,9,6,3,6,299,8,6,1,7,1,7,1,7,5,7,304,8,7,10,7,12,7,307,9,7,1,
        7,3,7,310,8,7,1,8,1,8,5,8,314,8,8,10,8,12,8,317,9,8,1,8,1,8,1,8,
        5,8,322,8,8,10,8,12,8,325,9,8,1,8,3,8,328,8,8,1,8,1,8,1,8,1,8,5,
        8,334,8,8,10,8,12,8,337,9,8,1,8,1,8,5,8,341,8,8,10,8,12,8,344,9,
        8,1,8,3,8,347,8,8,1,8,1,8,5,8,351,8,8,10,8,12,8,354,9,8,1,8,3,8,
        357,8,8,1,8,1,8,5,8,361,8,8,10,8,12,8,364,9,8,1,8,1,8,1,8,1,8,1,
        8,5,8,371,8,8,10,8,12,8,374,9,8,1,8,1,8,5,8,378,8,8,10,8,12,8,381,
        9,8,1,8,1,8,1,8,5,8,386,8,8,10,8,12,8,389,9,8,1,8,5,8,392,8,8,10,
        8,12,8,395,9,8,1,8,1,8,5,8,399,8,8,10,8,12,8,402,9,8,1,8,1,8,5,8,
        406,8,8,10,8,12,8,409,9,8,1,8,1,8,1,8,3,8,414,8,8,1,9,1,9,1,10,1,
        10,5,10,420,8,10,10,10,12,10,423,9,10,3,10,425,8,10,1,10,1,10,5,
        10,429,8,10,10,10,12,10,432,9,10,1,10,1,10,1,10,5,10,437,8,10,10,
        10,12,10,440,9,10,1,10,1,10,1,10,5,10,445,8,10,10,10,12,10,448,9,
        10,1,10,5,10,451,8,10,10,10,12,10,454,9,10,3,10,456,8,10,1,10,1,
        10,5,10,460,8,10,10,10,12,10,463,9,10,1,10,5,10,466,8,10,10,10,12,
        10,469,9,10,1,10,1,10,5,10,473,8,10,10,10,12,10,476,9,10,1,11,1,
        11,1,11,5,11,481,8,11,10,11,12,11,484,9,11,1,11,3,11,487,8,11,1,
        11,1,11,5,11,491,8,11,10,11,12,11,494,9,11,3,11,496,8,11,1,12,1,
        12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,3,12,507,8,12,1,13,1,13,1,
        13,5,13,512,8,13,10,13,12,13,515,9,13,1,13,1,13,5,13,519,8,13,10,
        13,12,13,522,9,13,1,13,1,13,5,13,526,8,13,10,13,12,13,529,9,13,1,
        13,1,13,5,13,533,8,13,10,13,12,13,536,9,13,1,13,1,13,5,13,540,8,
        13,10,13,12,13,543,9,13,1,13,5,13,546,8,13,10,13,12,13,549,9,13,
        1,13,1,13,1,13,5,13,554,8,13,10,13,12,13,557,9,13,1,13,3,13,560,
        8,13,1,13,1,13,1,14,1,14,1,14,5,14,567,8,14,10,14,12,14,570,9,14,
        1,14,1,14,1,14,5,14,575,8,14,10,14,12,14,578,9,14,1,14,1,14,1,14,
        1,15,1,15,5,15,585,8,15,10,15,12,15,588,9,15,1,15,1,15,1,15,1,15,
        1,16,1,16,5,16,596,8,16,10,16,12,16,599,9,16,1,16,1,16,1,16,5,16,
        604,8,16,10,16,12,16,607,9,16,1,16,1,16,1,16,1,17,1,17,5,17,614,
        8,17,10,17,12,17,617,9,17,1,17,1,17,1,17,5,17,622,8,17,10,17,12,
        17,625,9,17,1,17,1,17,5,17,629,8,17,10,17,12,17,632,9,17,1,17,3,
        17,635,8,17,1,17,1,17,5,17,639,8,17,10,17,12,17,642,9,17,3,17,644,
        8,17,1,17,1,17,1,18,1,18,1,18,5,18,651,8,18,10,18,12,18,654,9,18,
        1,18,1,18,1,18,5,18,659,8,18,10,18,12,18,662,9,18,1,18,5,18,665,
        8,18,10,18,12,18,668,9,18,1,18,1,18,5,18,672,8,18,10,18,12,18,675,
        9,18,3,18,677,8,18,1,19,1,19,1,19,5,19,682,8,19,10,19,12,19,685,
        9,19,1,19,3,19,688,8,19,1,20,1,20,5,20,692,8,20,10,20,12,20,695,
        9,20,1,21,1,21,5,21,699,8,21,10,21,12,21,702,9,21,1,21,1,21,1,21,
        5,21,707,8,21,10,21,12,21,710,9,21,1,21,1,21,1,21,1,21,1,21,5,21,
        717,8,21,10,21,12,21,720,9,21,3,21,722,8,21,1,21,1,21,5,21,726,8,
        21,10,21,12,21,729,9,21,1,22,1,22,5,22,733,8,22,10,22,12,22,736,
        9,22,1,22,1,22,3,22,740,8,22,1,22,1,22,5,22,744,8,22,10,22,12,22,
        747,9,22,1,22,5,22,750,8,22,10,22,12,22,753,9,22,1,22,1,22,3,22,
        757,8,22,1,23,1,23,1,23,5,23,762,8,23,10,23,12,23,765,9,23,1,23,
        3,23,768,8,23,1,23,1,23,5,23,772,8,23,10,23,12,23,775,9,23,3,23,
        777,8,23,1,24,1,24,1,24,1,24,3,24,783,8,24,1,24,1,24,3,24,787,8,
        24,1,25,1,25,5,25,791,8,25,10,25,12,25,794,9,25,1,25,3,25,797,8,
        25,1,25,1,25,5,25,801,8,25,10,25,12,25,804,9,25,1,25,1,25,5,25,808,
        8,25,10,25,12,25,811,9,25,1,25,1,25,5,25,815,8,25,10,25,12,25,818,
        9,25,3,25,820,8,25,1,26,1,26,5,26,824,8,26,10,26,12,26,827,9,26,
        1,26,1,26,1,27,1,27,5,27,833,8,27,10,27,12,27,836,9,27,1,27,1,27,
        5,27,840,8,27,10,27,12,27,843,9,27,1,27,1,27,5,27,847,8,27,10,27,
        12,27,850,9,27,1,27,1,27,5,27,854,8,27,10,27,12,27,857,9,27,1,27,
        1,27,5,27,861,8,27,10,27,12,27,864,9,27,1,27,1,27,1,27,5,27,869,
        8,27,10,27,12,27,872,9,27,1,28,1,28,5,28,876,8,28,10,28,12,28,879,
        9,28,1,28,1,28,1,28,1,28,5,28,885,8,28,10,28,12,28,888,9,28,3,28,
        890,8,28,1,28,1,28,1,29,1,29,1,30,1,30,5,30,898,8,30,10,30,12,30,
        901,9,30,1,30,1,30,1,30,5,30,906,8,30,10,30,12,30,909,9,30,1,30,
        3,30,912,8,30,1,30,1,30,5,30,916,8,30,10,30,12,30,919,9,30,1,30,
        5,30,922,8,30,10,30,12,30,925,9,30,1,30,1,30,5,30,929,8,30,10,30,
        12,30,932,9,30,1,31,1,31,5,31,936,8,31,10,31,12,31,939,9,31,1,31,
        1,31,1,31,5,31,944,8,31,10,31,12,31,947,9,31,1,31,5,31,950,8,31,
        10,31,12,31,953,9,31,3,31,955,8,31,1,31,1,31,5,31,959,8,31,10,31,
        12,31,962,9,31,1,32,1,32,3,32,966,8,32,1,32,3,32,969,8,32,1,33,1,
        33,5,33,973,8,33,10,33,12,33,976,9,33,1,33,1,33,1,33,5,33,981,8,
        33,10,33,12,33,984,9,33,1,33,5,33,987,8,33,10,33,12,33,990,9,33,
        3,33,992,8,33,1,33,1,33,5,33,996,8,33,10,33,12,33,999,9,33,1,34,
        1,34,1,34,5,34,1004,8,34,10,34,12,34,1007,9,34,3,34,1009,8,34,1,
        34,3,34,1012,8,34,1,35,1,35,5,35,1016,8,35,10,35,12,35,1019,9,35,
        1,35,1,35,1,35,5,35,1024,8,35,10,35,12,35,1027,9,35,1,35,5,35,1030,
        8,35,10,35,12,35,1033,9,35,3,35,1035,8,35,1,35,1,35,5,35,1039,8,
        35,10,35,12,35,1042,9,35,1,36,1,36,3,36,1046,8,36,1,37,1,37,3,37,
        1050,8,37,1,37,1,37,1,38,1,38,1,38,1,38,1,38,1,38,1,38,5,38,1061,
        8,38,10,38,12,38,1064,9,38,1,38,1,38,5,38,1068,8,38,10,38,12,38,
        1071,9,38,3,38,1073,8,38,1,38,1,38,1,38,5,38,1078,8,38,10,38,12,
        38,1081,9,38,1,38,3,38,1084,8,38,1,38,1,38,5,38,1088,8,38,10,38,
        12,38,1091,9,38,5,38,1093,8,38,10,38,12,38,1096,9,38,1,39,1,39,1,
        39,5,39,1101,8,39,10,39,12,39,1104,9,39,1,39,5,39,1107,8,39,10,39,
        12,39,1110,9,39,1,40,1,40,3,40,1114,8,40,1,41,1,41,5,41,1118,8,41,
        10,41,12,41,1121,9,41,1,41,1,41,5,41,1125,8,41,10,41,12,41,1128,
        9,41,1,41,1,41,3,41,1132,8,41,1,41,1,41,5,41,1136,8,41,10,41,12,
        41,1139,9,41,1,41,1,41,3,41,1143,8,41,1,41,1,41,5,41,1147,8,41,10,
        41,12,41,1150,9,41,1,42,1,42,1,43,1,43,1,44,1,44,5,44,1158,8,44,
        10,44,12,44,1161,9,44,1,44,1,44,1,44,5,44,1166,8,44,10,44,12,44,
        1169,9,44,1,44,1,44,5,44,1173,8,44,10,44,12,44,1176,9,44,1,44,5,
        44,1179,8,44,10,44,12,44,1182,9,44,1,44,1,44,5,44,1186,8,44,10,44,
        12,44,1189,9,44,1,44,3,44,1192,8,44,1,45,1,45,5,45,1196,8,45,10,
        45,12,45,1199,9,45,1,46,1,46,5,46,1203,8,46,10,46,12,46,1206,9,46,
        1,47,1,47,5,47,1210,8,47,10,47,12,47,1213,9,47,1,47,5,47,1216,8,
        47,10,47,12,47,1219,9,47,1,47,1,47,5,47,1223,8,47,10,47,12,47,1226,
        9,47,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,
        1,48,1,48,1,48,3,48,1243,8,48,1,49,1,49,1,49,1,50,1,50,5,50,1250,
        8,50,10,50,12,50,1253,9,50,1,50,1,50,5,50,1257,8,50,10,50,12,50,
        1260,9,50,1,50,1,50,1,50,5,50,1265,8,50,10,50,12,50,1268,9,50,1,
        50,1,50,1,50,5,50,1273,8,50,10,50,12,50,1276,9,50,1,50,3,50,1279,
        8,50,1,51,1,51,5,51,1283,8,51,10,51,12,51,1286,9,51,1,51,1,51,3,
        51,1290,8,51,1,51,1,51,4,51,1294,8,51,11,51,12,51,1295,1,52,1,52,
        5,52,1300,8,52,10,52,12,52,1303,9,52,1,52,3,52,1306,8,52,1,52,3,
        52,1309,8,52,1,52,1,52,1,53,1,53,5,53,1315,8,53,10,53,12,53,1318,
        9,53,1,53,1,53,5,53,1322,8,53,10,53,12,53,1325,9,53,1,53,1,53,1,
        53,5,53,1330,8,53,10,53,12,53,1333,9,53,1,53,1,53,1,54,1,54,3,54,
        1339,8,54,1,55,1,55,5,55,1343,8,55,10,55,12,55,1346,9,55,1,55,1,
        55,1,56,1,56,5,56,1352,8,56,10,56,12,56,1355,9,56,1,56,1,56,5,56,
        1359,8,56,10,56,12,56,1362,9,56,1,56,1,56,1,56,5,56,1367,8,56,10,
        56,12,56,1370,9,56,3,56,1372,8,56,1,56,1,56,1,56,5,56,1377,8,56,
        10,56,12,56,1380,9,56,3,56,1382,8,56,1,56,3,56,1385,8,56,1,56,1,
        56,5,56,1389,8,56,10,56,12,56,1392,9,56,1,56,1,56,1,57,1,57,5,57,
        1398,8,57,10,57,12,57,1401,9,57,1,57,1,57,5,57,1405,8,57,10,57,12,
        57,1408,9,57,3,57,1410,8,57,1,57,1,57,5,57,1414,8,57,10,57,12,57,
        1417,9,57,1,57,1,57,1,57,5,57,1422,8,57,10,57,12,57,1425,9,57,3,
        57,1427,8,57,1,57,1,57,1,58,1,58,1,59,1,59,5,59,1435,8,59,10,59,
        12,59,1438,9,59,1,59,1,59,1,59,5,59,1443,8,59,10,59,12,59,1446,9,
        59,1,59,1,59,5,59,1450,8,59,10,59,12,59,1453,9,59,1,59,1,59,1,59,
        1,59,1,60,1,60,1,60,1,61,1,61,1,61,1,62,1,62,5,62,1467,8,62,10,62,
        12,62,1470,9,62,1,62,3,62,1473,8,62,1,62,1,62,1,63,1,63,1,63,1,64,
        1,64,5,64,1482,8,64,10,64,12,64,1485,9,64,1,64,1,64,1,64,1,65,1,
        65,5,65,1492,8,65,10,65,12,65,1495,9,65,1,65,1,65,1,65,1,66,1,66,
        5,66,1502,8,66,10,66,12,66,1505,9,66,1,66,1,66,1,66,1,66,5,66,1511,
        8,66,10,66,12,66,1514,9,66,1,66,1,66,1,66,5,66,1519,8,66,10,66,12,
        66,1522,9,66,3,66,1524,8,66,1,66,1,66,5,66,1528,8,66,10,66,12,66,
        1531,9,66,1,66,3,66,1534,8,66,1,66,1,66,1,67,3,67,1539,8,67,1,67,
        1,67,5,67,1543,8,67,10,67,12,67,1546,9,67,1,67,3,67,1549,8,67,5,
        67,1551,8,67,10,67,12,67,1554,9,67,1,68,1,68,5,68,1558,8,68,10,68,
        12,68,1561,9,68,1,68,3,68,1564,8,68,1,68,1,68,5,68,1568,8,68,10,
        68,12,68,1571,9,68,5,68,1573,8,68,10,68,12,68,1576,9,68,1,68,3,68,
        1579,8,68,1,68,1,68,5,68,1583,8,68,10,68,12,68,1586,9,68,1,69,1,
        69,5,69,1590,8,69,10,69,12,69,1593,9,69,1,70,1,70,1,70,5,70,1598,
        8,70,10,70,12,70,1601,9,70,1,70,1,70,1,70,5,70,1606,8,70,10,70,12,
        70,1609,9,70,1,70,1,70,1,70,5,70,1614,8,70,10,70,12,70,1617,9,70,
        1,70,1,70,5,70,1621,8,70,10,70,12,70,1624,9,70,1,70,1,70,1,70,5,
        70,1629,8,70,10,70,12,70,1632,9,70,1,70,1,70,1,70,5,70,1637,8,70,
        10,70,12,70,1640,9,70,1,70,1,70,1,70,5,70,1645,8,70,10,70,12,70,
        1648,9,70,1,70,1,70,1,70,5,70,1653,8,70,10,70,12,70,1656,9,70,1,
        70,1,70,3,70,1660,8,70,1,70,1,70,1,70,5,70,1665,8,70,10,70,12,70,
        1668,9,70,1,70,1,70,1,70,1,70,5,70,1674,8,70,10,70,12,70,1677,9,
        70,1,70,1,70,1,70,1,70,5,70,1683,8,70,10,70,12,70,1686,9,70,1,70,
        1,70,1,70,1,70,5,70,1692,8,70,10,70,12,70,1695,9,70,1,70,1,70,1,
        70,1,70,5,70,1701,8,70,10,70,12,70,1704,9,70,1,70,1,70,1,70,1,70,
        5,70,1710,8,70,10,70,12,70,1713,9,70,1,70,1,70,1,70,1,70,5,70,1719,
        8,70,10,70,12,70,1722,9,70,1,70,1,70,1,70,1,70,5,70,1728,8,70,10,
        70,12,70,1731,9,70,1,70,1,70,1,70,1,70,5,70,1737,8,70,10,70,12,70,
        1740,9,70,1,70,1,70,1,70,1,70,5,70,1746,8,70,10,70,12,70,1749,9,
        70,1,70,1,70,1,70,1,70,5,70,1755,8,70,10,70,12,70,1758,9,70,1,70,
        1,70,1,70,1,70,5,70,1764,8,70,10,70,12,70,1767,9,70,1,70,1,70,1,
        70,5,70,1772,8,70,10,70,12,70,1775,9,70,1,70,1,70,1,70,1,70,1,70,
        5,70,1782,8,70,10,70,12,70,1785,9,70,1,70,1,70,1,70,1,70,5,70,1791,
        8,70,10,70,12,70,1794,9,70,1,70,1,70,1,70,5,70,1799,8,70,10,70,12,
        70,1802,9,70,1,70,1,70,1,70,5,70,1807,8,70,10,70,12,70,1810,9,70,
        1,70,1,70,1,70,5,70,1815,8,70,10,70,12,70,1818,9,70,1,70,3,70,1821,
        8,70,1,70,1,70,5,70,1825,8,70,10,70,12,70,1828,9,70,1,70,3,70,1831,
        8,70,1,70,1,70,5,70,1835,8,70,10,70,12,70,1838,9,70,1,70,1,70,1,
        70,5,70,1843,8,70,10,70,12,70,1846,9,70,1,70,1,70,1,70,1,70,5,70,
        1852,8,70,10,70,12,70,1855,9,70,1,70,1,70,1,70,5,70,1860,8,70,10,
        70,12,70,1863,9,70,1,70,1,70,1,70,5,70,1868,8,70,10,70,12,70,1871,
        9,70,1,70,1,70,1,70,5,70,1876,8,70,10,70,12,70,1879,9,70,5,70,1881,
        8,70,10,70,12,70,1884,9,70,1,71,1,71,5,71,1888,8,71,10,71,12,71,
        1891,9,71,1,71,1,71,1,71,1,71,1,71,1,71,5,71,1899,8,71,10,71,12,
        71,1902,9,71,1,71,1,71,5,71,1906,8,71,10,71,12,71,1909,9,71,1,71,
        1,71,3,71,1913,8,71,1,72,1,72,1,72,5,72,1918,8,72,10,72,12,72,1921,
        9,72,1,72,5,72,1924,8,72,10,72,12,72,1927,9,72,1,73,1,73,1,73,5,
        73,1932,8,73,10,73,12,73,1935,9,73,1,73,5,73,1938,8,73,10,73,12,
        73,1941,9,73,1,73,1,73,5,73,1945,8,73,10,73,12,73,1948,9,73,3,73,
        1950,8,73,1,74,1,74,1,74,5,74,1955,8,74,10,74,12,74,1958,9,74,1,
        74,1,74,1,75,1,75,5,75,1964,8,75,10,75,12,75,1967,9,75,1,75,3,75,
        1970,8,75,1,75,1,75,5,75,1974,8,75,10,75,12,75,1977,9,75,1,75,3,
        75,1980,8,75,3,75,1982,8,75,1,76,1,76,1,76,5,76,1987,8,76,10,76,
        12,76,1990,9,76,1,76,1,76,1,76,5,76,1995,8,76,10,76,12,76,1998,9,
        76,1,77,1,77,5,77,2002,8,77,10,77,12,77,2005,9,77,1,77,5,77,2008,
        8,77,10,77,12,77,2011,9,77,1,77,1,77,5,77,2015,8,77,10,77,12,77,
        2018,9,77,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,
        1,78,1,78,5,78,2033,8,78,10,78,12,78,2036,9,78,1,78,1,78,5,78,2040,
        8,78,10,78,12,78,2043,9,78,1,78,1,78,5,78,2047,8,78,10,78,12,78,
        2050,9,78,1,78,1,78,1,78,3,78,2055,8,78,1,79,1,79,1,79,3,79,2060,
        8,79,1,80,1,80,1,80,5,80,2065,8,80,10,80,12,80,2068,9,80,1,80,1,
        80,1,81,1,81,5,81,2074,8,81,10,81,12,81,2077,9,81,1,81,1,81,5,81,
        2081,8,81,10,81,12,81,2084,9,81,1,81,1,81,5,81,2088,8,81,10,81,12,
        81,2091,9,81,1,81,3,81,2094,8,81,1,81,1,81,5,81,2098,8,81,10,81,
        12,81,2101,9,81,1,81,3,81,2104,8,81,1,81,1,81,5,81,2108,8,81,10,
        81,12,81,2111,9,81,1,81,5,81,2114,8,81,10,81,12,81,2117,9,81,1,81,
        1,81,5,81,2121,8,81,10,81,12,81,2124,9,81,3,81,2126,8,81,1,82,1,
        82,5,82,2130,8,82,10,82,12,82,2133,9,82,1,82,1,82,1,82,5,82,2138,
        8,82,10,82,12,82,2141,9,82,1,82,3,82,2144,8,82,1,83,1,83,1,83,5,
        83,2149,8,83,10,83,12,83,2152,9,83,1,83,1,83,1,84,1,84,1,84,1,84,
        1,84,5,84,2161,8,84,10,84,12,84,2164,9,84,1,84,1,84,1,84,5,84,2169,
        8,84,10,84,12,84,2172,9,84,3,84,2174,8,84,1,85,1,85,1,85,5,85,2179,
        8,85,10,85,12,85,2182,9,85,1,85,5,85,2185,8,85,10,85,12,85,2188,
        9,85,1,86,1,86,1,86,5,86,2193,8,86,10,86,12,86,2196,9,86,1,86,1,
        86,1,87,1,87,1,87,5,87,2203,8,87,10,87,12,87,2206,9,87,1,88,1,88,
        5,88,2210,8,88,10,88,12,88,2213,9,88,1,88,1,88,5,88,2217,8,88,10,
        88,12,88,2220,9,88,1,89,1,89,5,89,2224,8,89,10,89,12,89,2227,9,89,
        1,89,1,89,1,89,1,89,1,89,5,89,2234,8,89,10,89,12,89,2237,9,89,1,
        89,3,89,2240,8,89,1,90,1,90,5,90,2244,8,90,10,90,12,90,2247,9,90,
        1,90,1,90,1,90,5,90,2252,8,90,10,90,12,90,2255,9,90,1,90,3,90,2258,
        8,90,1,90,1,90,5,90,2262,8,90,10,90,12,90,2265,9,90,1,90,3,90,2268,
        8,90,1,90,1,90,1,91,1,91,5,91,2274,8,91,10,91,12,91,2277,9,91,1,
        91,1,91,1,92,1,92,5,92,2283,8,92,10,92,12,92,2286,9,92,1,92,1,92,
        3,92,2290,8,92,1,92,1,92,1,92,3,92,2295,8,92,1,92,1,92,1,93,1,93,
        5,93,2301,8,93,10,93,12,93,2304,9,93,1,93,1,93,1,93,1,94,1,94,1,
        94,5,94,2312,8,94,10,94,12,94,2315,9,94,1,94,1,94,5,94,2319,8,94,
        10,94,12,94,2322,9,94,1,94,1,94,3,94,2326,8,94,1,95,1,95,5,95,2330,
        8,95,10,95,12,95,2333,9,95,1,95,3,95,2336,8,95,1,95,1,95,5,95,2340,
        8,95,10,95,12,95,2343,9,95,1,95,3,95,2346,8,95,5,95,2348,8,95,10,
        95,12,95,2351,9,95,1,95,1,95,5,95,2355,8,95,10,95,12,95,2358,9,95,
        1,95,1,95,5,95,2362,8,95,10,95,12,95,2365,9,95,1,95,1,95,1,95,5,
        95,2370,8,95,10,95,12,95,2373,9,95,1,95,5,95,2376,8,95,10,95,12,
        95,2379,9,95,3,95,2381,8,95,1,95,1,95,5,95,2385,8,95,10,95,12,95,
        2388,9,95,3,95,2390,8,95,1,96,1,96,5,96,2394,8,96,10,96,12,96,2397,
        9,96,1,96,1,96,5,96,2401,8,96,10,96,12,96,2404,9,96,3,96,2406,8,
        96,1,96,1,96,5,96,2410,8,96,10,96,12,96,2413,9,96,3,96,2415,8,96,
        1,97,1,97,5,97,2419,8,97,10,97,12,97,2422,9,97,1,98,1,98,5,98,2426,
        8,98,10,98,12,98,2429,9,98,4,98,2431,8,98,11,98,12,98,2432,1,99,
        1,99,5,99,2437,8,99,10,99,12,99,2440,9,99,1,99,1,99,5,99,2444,8,
        99,10,99,12,99,2447,9,99,1,99,1,99,1,99,5,99,2452,8,99,10,99,12,
        99,2455,9,99,1,99,5,99,2458,8,99,10,99,12,99,2461,9,99,1,99,1,99,
        5,99,2465,8,99,10,99,12,99,2468,9,99,3,99,2470,8,99,1,100,1,100,
        5,100,2474,8,100,10,100,12,100,2477,9,100,4,100,2479,8,100,11,100,
        12,100,2480,1,101,5,101,2484,8,101,10,101,12,101,2487,9,101,1,101,
        1,101,5,101,2491,8,101,10,101,12,101,2494,9,101,1,101,4,101,2497,
        8,101,11,101,12,101,2498,3,101,2501,8,101,1,101,0,2,76,140,102,0,
        2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,
        48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,
        92,94,96,98,100,102,104,106,108,110,112,114,116,118,120,122,124,
        126,128,130,132,134,136,138,140,142,144,146,148,150,152,154,156,
        158,160,162,164,166,168,170,172,174,176,178,180,182,184,186,188,
        190,192,194,196,198,200,202,0,14,1,0,4,10,1,0,18,20,3,0,2,2,4,9,
        27,34,1,0,47,49,4,0,110,110,117,117,121,121,123,123,3,0,43,43,63,
        66,97,101,1,0,67,68,1,0,29,30,2,0,2,2,31,32,1,0,74,75,1,0,6,9,1,
        0,33,34,2,0,10,10,78,87,10,0,13,13,24,24,43,43,49,49,62,62,95,95,
        113,113,117,117,124,125,127,128,2861,0,207,1,0,0,0,2,231,1,0,0,0,
        4,242,1,0,0,0,6,253,1,0,0,0,8,255,1,0,0,0,10,271,1,0,0,0,12,298,
        1,0,0,0,14,300,1,0,0,0,16,413,1,0,0,0,18,415,1,0,0,0,20,424,1,0,
        0,0,22,477,1,0,0,0,24,506,1,0,0,0,26,508,1,0,0,0,28,563,1,0,0,0,
        30,582,1,0,0,0,32,593,1,0,0,0,34,611,1,0,0,0,36,676,1,0,0,0,38,678,
        1,0,0,0,40,689,1,0,0,0,42,696,1,0,0,0,44,730,1,0,0,0,46,758,1,0,
        0,0,48,778,1,0,0,0,50,819,1,0,0,0,52,821,1,0,0,0,54,870,1,0,0,0,
        56,873,1,0,0,0,58,893,1,0,0,0,60,895,1,0,0,0,62,933,1,0,0,0,64,963,
        1,0,0,0,66,970,1,0,0,0,68,1000,1,0,0,0,70,1013,1,0,0,0,72,1043,1,
        0,0,0,74,1047,1,0,0,0,76,1072,1,0,0,0,78,1097,1,0,0,0,80,1113,1,
        0,0,0,82,1115,1,0,0,0,84,1151,1,0,0,0,86,1153,1,0,0,0,88,1155,1,
        0,0,0,90,1193,1,0,0,0,92,1200,1,0,0,0,94,1207,1,0,0,0,96,1242,1,
        0,0,0,98,1244,1,0,0,0,100,1247,1,0,0,0,102,1280,1,0,0,0,104,1297,
        1,0,0,0,106,1312,1,0,0,0,108,1338,1,0,0,0,110,1340,1,0,0,0,112,1349,
        1,0,0,0,114,1395,1,0,0,0,116,1430,1,0,0,0,118,1432,1,0,0,0,120,1458,
        1,0,0,0,122,1461,1,0,0,0,124,1464,1,0,0,0,126,1476,1,0,0,0,128,1479,
        1,0,0,0,130,1489,1,0,0,0,132,1523,1,0,0,0,134,1538,1,0,0,0,136,1555,
        1,0,0,0,138,1587,1,0,0,0,140,1659,1,0,0,0,142,1912,1,0,0,0,144,1914,
        1,0,0,0,146,1928,1,0,0,0,148,1951,1,0,0,0,150,1981,1,0,0,0,152,1983,
        1,0,0,0,154,1999,1,0,0,0,156,2054,1,0,0,0,158,2059,1,0,0,0,160,2061,
        1,0,0,0,162,2093,1,0,0,0,164,2127,1,0,0,0,166,2145,1,0,0,0,168,2173,
        1,0,0,0,170,2175,1,0,0,0,172,2189,1,0,0,0,174,2199,1,0,0,0,176,2207,
        1,0,0,0,178,2239,1,0,0,0,180,2241,1,0,0,0,182,2271,1,0,0,0,184,2280,
        1,0,0,0,186,2298,1,0,0,0,188,2325,1,0,0,0,190,2389,1,0,0,0,192,2405,
        1,0,0,0,194,2416,1,0,0,0,196,2430,1,0,0,0,198,2434,1,0,0,0,200,2478,
        1,0,0,0,202,2500,1,0,0,0,204,206,5,131,0,0,205,204,1,0,0,0,206,209,
        1,0,0,0,207,205,1,0,0,0,207,208,1,0,0,0,208,226,1,0,0,0,209,207,
        1,0,0,0,210,225,3,2,1,0,211,225,3,16,8,0,212,225,3,20,10,0,213,225,
        3,24,12,0,214,225,3,60,30,0,215,225,3,42,21,0,216,225,3,48,24,0,
        217,225,3,28,14,0,218,225,3,30,15,0,219,225,3,32,16,0,220,225,3,
        34,17,0,221,225,3,98,49,0,222,225,3,94,47,0,223,225,3,96,48,0,224,
        210,1,0,0,0,224,211,1,0,0,0,224,212,1,0,0,0,224,213,1,0,0,0,224,
        214,1,0,0,0,224,215,1,0,0,0,224,216,1,0,0,0,224,217,1,0,0,0,224,
        218,1,0,0,0,224,219,1,0,0,0,224,220,1,0,0,0,224,221,1,0,0,0,224,
        222,1,0,0,0,224,223,1,0,0,0,225,228,1,0,0,0,226,224,1,0,0,0,226,
        227,1,0,0,0,227,229,1,0,0,0,228,226,1,0,0,0,229,230,5,0,0,1,230,
        1,1,0,0,0,231,235,5,1,0,0,232,234,5,131,0,0,233,232,1,0,0,0,234,
        237,1,0,0,0,235,233,1,0,0,0,235,236,1,0,0,0,236,238,1,0,0,0,237,
        235,1,0,0,0,238,239,3,4,2,0,239,240,3,6,3,0,240,241,3,202,101,0,
        241,3,1,0,0,0,242,243,3,194,97,0,243,5,1,0,0,0,244,248,5,2,0,0,245,
        247,5,131,0,0,246,245,1,0,0,0,247,250,1,0,0,0,248,246,1,0,0,0,248,
        249,1,0,0,0,249,254,1,0,0,0,250,248,1,0,0,0,251,254,3,8,4,0,252,
        254,3,140,70,0,253,244,1,0,0,0,253,251,1,0,0,0,253,252,1,0,0,0,254,
        7,1,0,0,0,255,268,3,12,6,0,256,260,5,3,0,0,257,259,5,131,0,0,258,
        257,1,0,0,0,259,262,1,0,0,0,260,258,1,0,0,0,260,261,1,0,0,0,261,
        264,1,0,0,0,262,260,1,0,0,0,263,256,1,0,0,0,263,264,1,0,0,0,264,
        265,1,0,0,0,265,267,3,12,6,0,266,263,1,0,0,0,267,270,1,0,0,0,268,
        266,1,0,0,0,268,269,1,0,0,0,269,9,1,0,0,0,270,268,1,0,0,0,271,275,
        7,0,0,0,272,274,5,131,0,0,273,272,1,0,0,0,274,277,1,0,0,0,275,273,
        1,0,0,0,275,276,1,0,0,0,276,11,1,0,0,0,277,275,1,0,0,0,278,280,3,
        10,5,0,279,278,1,0,0,0,279,280,1,0,0,0,280,281,1,0,0,0,281,285,5,
        130,0,0,282,284,5,131,0,0,283,282,1,0,0,0,284,287,1,0,0,0,285,283,
        1,0,0,0,285,286,1,0,0,0,286,299,1,0,0,0,287,285,1,0,0,0,288,290,
        3,10,5,0,289,288,1,0,0,0,289,290,1,0,0,0,290,291,1,0,0,0,291,295,
        5,103,0,0,292,294,5,131,0,0,293,292,1,0,0,0,294,297,1,0,0,0,295,
        293,1,0,0,0,295,296,1,0,0,0,296,299,1,0,0,0,297,295,1,0,0,0,298,
        279,1,0,0,0,298,289,1,0,0,0,299,13,1,0,0,0,300,309,3,194,97,0,301,
        305,5,11,0,0,302,304,5,131,0,0,303,302,1,0,0,0,304,307,1,0,0,0,305,
        303,1,0,0,0,305,306,1,0,0,0,306,308,1,0,0,0,307,305,1,0,0,0,308,
        310,3,194,97,0,309,301,1,0,0,0,309,310,1,0,0,0,310,15,1,0,0,0,311,
        315,5,12,0,0,312,314,5,131,0,0,313,312,1,0,0,0,314,317,1,0,0,0,315,
        313,1,0,0,0,315,316,1,0,0,0,316,318,1,0,0,0,317,315,1,0,0,0,318,
        327,3,18,9,0,319,323,5,11,0,0,320,322,5,131,0,0,321,320,1,0,0,0,
        322,325,1,0,0,0,323,321,1,0,0,0,323,324,1,0,0,0,324,326,1,0,0,0,
        325,323,1,0,0,0,326,328,3,194,97,0,327,319,1,0,0,0,327,328,1,0,0,
        0,328,329,1,0,0,0,329,330,3,202,101,0,330,414,1,0,0,0,331,335,5,
        12,0,0,332,334,5,131,0,0,333,332,1,0,0,0,334,337,1,0,0,0,335,333,
        1,0,0,0,335,336,1,0,0,0,336,346,1,0,0,0,337,335,1,0,0,0,338,342,
        5,2,0,0,339,341,5,131,0,0,340,339,1,0,0,0,341,344,1,0,0,0,342,340,
        1,0,0,0,342,343,1,0,0,0,343,347,1,0,0,0,344,342,1,0,0,0,345,347,
        3,194,97,0,346,338,1,0,0,0,346,345,1,0,0,0,347,356,1,0,0,0,348,352,
        5,11,0,0,349,351,5,131,0,0,350,349,1,0,0,0,351,354,1,0,0,0,352,350,
        1,0,0,0,352,353,1,0,0,0,353,355,1,0,0,0,354,352,1,0,0,0,355,357,
        3,194,97,0,356,348,1,0,0,0,356,357,1,0,0,0,357,358,1,0,0,0,358,362,
        5,13,0,0,359,361,5,131,0,0,360,359,1,0,0,0,361,364,1,0,0,0,362,360,
        1,0,0,0,362,363,1,0,0,0,363,365,1,0,0,0,364,362,1,0,0,0,365,366,
        3,18,9,0,366,367,3,202,101,0,367,414,1,0,0,0,368,372,5,12,0,0,369,
        371,5,131,0,0,370,369,1,0,0,0,371,374,1,0,0,0,372,370,1,0,0,0,372,
        373,1,0,0,0,373,375,1,0,0,0,374,372,1,0,0,0,375,379,5,14,0,0,376,
        378,5,131,0,0,377,376,1,0,0,0,378,381,1,0,0,0,379,377,1,0,0,0,379,
        380,1,0,0,0,380,382,1,0,0,0,381,379,1,0,0,0,382,393,3,14,7,0,383,
        387,5,15,0,0,384,386,5,131,0,0,385,384,1,0,0,0,386,389,1,0,0,0,387,
        385,1,0,0,0,387,388,1,0,0,0,388,390,1,0,0,0,389,387,1,0,0,0,390,
        392,3,14,7,0,391,383,1,0,0,0,392,395,1,0,0,0,393,391,1,0,0,0,393,
        394,1,0,0,0,394,396,1,0,0,0,395,393,1,0,0,0,396,400,5,16,0,0,397,
        399,5,131,0,0,398,397,1,0,0,0,399,402,1,0,0,0,400,398,1,0,0,0,400,
        401,1,0,0,0,401,403,1,0,0,0,402,400,1,0,0,0,403,407,5,13,0,0,404,
        406,5,131,0,0,405,404,1,0,0,0,406,409,1,0,0,0,407,405,1,0,0,0,407,
        408,1,0,0,0,408,410,1,0,0,0,409,407,1,0,0,0,410,411,3,18,9,0,411,
        412,3,202,101,0,412,414,1,0,0,0,413,311,1,0,0,0,413,331,1,0,0,0,
        413,368,1,0,0,0,414,17,1,0,0,0,415,416,5,129,0,0,416,19,1,0,0,0,
        417,421,5,17,0,0,418,420,5,131,0,0,419,418,1,0,0,0,420,423,1,0,0,
        0,421,419,1,0,0,0,421,422,1,0,0,0,422,425,1,0,0,0,423,421,1,0,0,
        0,424,417,1,0,0,0,424,425,1,0,0,0,425,426,1,0,0,0,426,430,7,1,0,
        0,427,429,5,131,0,0,428,427,1,0,0,0,429,432,1,0,0,0,430,428,1,0,
        0,0,430,431,1,0,0,0,431,433,1,0,0,0,432,430,1,0,0,0,433,455,3,194,
        97,0,434,438,5,21,0,0,435,437,5,131,0,0,436,435,1,0,0,0,437,440,
        1,0,0,0,438,436,1,0,0,0,438,439,1,0,0,0,439,441,1,0,0,0,440,438,
        1,0,0,0,441,452,3,22,11,0,442,446,5,15,0,0,443,445,5,131,0,0,444,
        443,1,0,0,0,445,448,1,0,0,0,446,444,1,0,0,0,446,447,1,0,0,0,447,
        449,1,0,0,0,448,446,1,0,0,0,449,451,3,22,11,0,450,442,1,0,0,0,451,
        454,1,0,0,0,452,450,1,0,0,0,452,453,1,0,0,0,453,456,1,0,0,0,454,
        452,1,0,0,0,455,434,1,0,0,0,455,456,1,0,0,0,456,457,1,0,0,0,457,
        461,5,14,0,0,458,460,5,131,0,0,459,458,1,0,0,0,460,463,1,0,0,0,461,
        459,1,0,0,0,461,462,1,0,0,0,462,467,1,0,0,0,463,461,1,0,0,0,464,
        466,3,24,12,0,465,464,1,0,0,0,466,469,1,0,0,0,467,465,1,0,0,0,467,
        468,1,0,0,0,468,470,1,0,0,0,469,467,1,0,0,0,470,474,5,16,0,0,471,
        473,5,131,0,0,472,471,1,0,0,0,473,476,1,0,0,0,474,472,1,0,0,0,474,
        475,1,0,0,0,475,21,1,0,0,0,476,474,1,0,0,0,477,495,3,78,39,0,478,
        482,5,22,0,0,479,481,5,131,0,0,480,479,1,0,0,0,481,484,1,0,0,0,482,
        480,1,0,0,0,482,483,1,0,0,0,483,486,1,0,0,0,484,482,1,0,0,0,485,
        487,3,144,72,0,486,485,1,0,0,0,486,487,1,0,0,0,487,488,1,0,0,0,488,
        492,5,23,0,0,489,491,5,131,0,0,490,489,1,0,0,0,491,494,1,0,0,0,492,
        490,1,0,0,0,492,493,1,0,0,0,493,496,1,0,0,0,494,492,1,0,0,0,495,
        478,1,0,0,0,495,496,1,0,0,0,496,23,1,0,0,0,497,507,3,26,13,0,498,
        507,3,34,17,0,499,507,3,42,21,0,500,507,3,44,22,0,501,507,3,48,24,
        0,502,507,3,56,28,0,503,507,3,60,30,0,504,507,3,30,15,0,505,507,
        3,32,16,0,506,497,1,0,0,0,506,498,1,0,0,0,506,499,1,0,0,0,506,500,
        1,0,0,0,506,501,1,0,0,0,506,502,1,0,0,0,506,503,1,0,0,0,506,504,
        1,0,0,0,506,505,1,0,0,0,507,25,1,0,0,0,508,547,3,76,38,0,509,513,
        5,119,0,0,510,512,5,131,0,0,511,510,1,0,0,0,512,515,1,0,0,0,513,
        511,1,0,0,0,513,514,1,0,0,0,514,546,1,0,0,0,515,513,1,0,0,0,516,
        520,5,116,0,0,517,519,5,131,0,0,518,517,1,0,0,0,519,522,1,0,0,0,
        520,518,1,0,0,0,520,521,1,0,0,0,521,546,1,0,0,0,522,520,1,0,0,0,
        523,527,5,118,0,0,524,526,5,131,0,0,525,524,1,0,0,0,526,529,1,0,
        0,0,527,525,1,0,0,0,527,528,1,0,0,0,528,546,1,0,0,0,529,527,1,0,
        0,0,530,534,5,110,0,0,531,533,5,131,0,0,532,531,1,0,0,0,533,536,
        1,0,0,0,534,532,1,0,0,0,534,535,1,0,0,0,535,546,1,0,0,0,536,534,
        1,0,0,0,537,541,5,111,0,0,538,540,5,131,0,0,539,538,1,0,0,0,540,
        543,1,0,0,0,541,539,1,0,0,0,541,542,1,0,0,0,542,546,1,0,0,0,543,
        541,1,0,0,0,544,546,3,198,99,0,545,509,1,0,0,0,545,516,1,0,0,0,545,
        523,1,0,0,0,545,530,1,0,0,0,545,537,1,0,0,0,545,544,1,0,0,0,546,
        549,1,0,0,0,547,545,1,0,0,0,547,548,1,0,0,0,548,550,1,0,0,0,549,
        547,1,0,0,0,550,559,3,194,97,0,551,555,5,10,0,0,552,554,5,131,0,
        0,553,552,1,0,0,0,554,557,1,0,0,0,555,553,1,0,0,0,555,556,1,0,0,
        0,556,558,1,0,0,0,557,555,1,0,0,0,558,560,3,140,70,0,559,551,1,0,
        0,0,559,560,1,0,0,0,560,561,1,0,0,0,561,562,3,202,101,0,562,27,1,
        0,0,0,563,564,3,76,38,0,564,568,5,110,0,0,565,567,5,131,0,0,566,
        565,1,0,0,0,567,570,1,0,0,0,568,566,1,0,0,0,568,569,1,0,0,0,569,
        571,1,0,0,0,570,568,1,0,0,0,571,572,3,194,97,0,572,576,5,10,0,0,
        573,575,5,131,0,0,574,573,1,0,0,0,575,578,1,0,0,0,576,574,1,0,0,
        0,576,577,1,0,0,0,577,579,1,0,0,0,578,576,1,0,0,0,579,580,3,140,
        70,0,580,581,3,202,101,0,581,29,1,0,0,0,582,586,5,24,0,0,583,585,
        5,131,0,0,584,583,1,0,0,0,585,588,1,0,0,0,586,584,1,0,0,0,586,587,
        1,0,0,0,587,589,1,0,0,0,588,586,1,0,0,0,589,590,3,194,97,0,590,591,
        3,62,31,0,591,592,3,202,101,0,592,31,1,0,0,0,593,597,5,122,0,0,594,
        596,5,131,0,0,595,594,1,0,0,0,596,599,1,0,0,0,597,595,1,0,0,0,597,
        598,1,0,0,0,598,600,1,0,0,0,599,597,1,0,0,0,600,601,3,194,97,0,601,
        605,5,21,0,0,602,604,5,131,0,0,603,602,1,0,0,0,604,607,1,0,0,0,605,
        603,1,0,0,0,605,606,1,0,0,0,606,608,1,0,0,0,607,605,1,0,0,0,608,
        609,3,138,69,0,609,610,3,202,101,0,610,33,1,0,0,0,611,615,5,25,0,
        0,612,614,5,131,0,0,613,612,1,0,0,0,614,617,1,0,0,0,615,613,1,0,
        0,0,615,616,1,0,0,0,616,618,1,0,0,0,617,615,1,0,0,0,618,619,3,36,
        18,0,619,623,5,26,0,0,620,622,5,131,0,0,621,620,1,0,0,0,622,625,
        1,0,0,0,623,621,1,0,0,0,623,624,1,0,0,0,624,634,1,0,0,0,625,623,
        1,0,0,0,626,630,5,2,0,0,627,629,5,131,0,0,628,627,1,0,0,0,629,632,
        1,0,0,0,630,628,1,0,0,0,630,631,1,0,0,0,631,635,1,0,0,0,632,630,
        1,0,0,0,633,635,3,76,38,0,634,626,1,0,0,0,634,633,1,0,0,0,635,643,
        1,0,0,0,636,640,5,124,0,0,637,639,5,131,0,0,638,637,1,0,0,0,639,
        642,1,0,0,0,640,638,1,0,0,0,640,641,1,0,0,0,641,644,1,0,0,0,642,
        640,1,0,0,0,643,636,1,0,0,0,643,644,1,0,0,0,644,645,1,0,0,0,645,
        646,3,202,101,0,646,35,1,0,0,0,647,677,3,78,39,0,648,652,5,14,0,
        0,649,651,5,131,0,0,650,649,1,0,0,0,651,654,1,0,0,0,652,650,1,0,
        0,0,652,653,1,0,0,0,653,655,1,0,0,0,654,652,1,0,0,0,655,666,3,38,
        19,0,656,660,5,15,0,0,657,659,5,131,0,0,658,657,1,0,0,0,659,662,
        1,0,0,0,660,658,1,0,0,0,660,661,1,0,0,0,661,663,1,0,0,0,662,660,
        1,0,0,0,663,665,3,38,19,0,664,656,1,0,0,0,665,668,1,0,0,0,666,664,
        1,0,0,0,666,667,1,0,0,0,667,669,1,0,0,0,668,666,1,0,0,0,669,673,
        5,16,0,0,670,672,5,131,0,0,671,670,1,0,0,0,672,675,1,0,0,0,673,671,
        1,0,0,0,673,674,1,0,0,0,674,677,1,0,0,0,675,673,1,0,0,0,676,647,
        1,0,0,0,676,648,1,0,0,0,677,37,1,0,0,0,678,687,3,78,39,0,679,683,
        5,11,0,0,680,682,5,131,0,0,681,680,1,0,0,0,682,685,1,0,0,0,683,681,
        1,0,0,0,683,684,1,0,0,0,684,686,1,0,0,0,685,683,1,0,0,0,686,688,
        3,40,20,0,687,679,1,0,0,0,687,688,1,0,0,0,688,39,1,0,0,0,689,693,
        7,2,0,0,690,692,5,131,0,0,691,690,1,0,0,0,692,695,1,0,0,0,693,691,
        1,0,0,0,693,694,1,0,0,0,694,41,1,0,0,0,695,693,1,0,0,0,696,700,5,
        35,0,0,697,699,5,131,0,0,698,697,1,0,0,0,699,702,1,0,0,0,700,698,
        1,0,0,0,700,701,1,0,0,0,701,703,1,0,0,0,702,700,1,0,0,0,703,704,
        3,194,97,0,704,708,5,14,0,0,705,707,5,131,0,0,706,705,1,0,0,0,707,
        710,1,0,0,0,708,706,1,0,0,0,708,709,1,0,0,0,709,721,1,0,0,0,710,
        708,1,0,0,0,711,712,3,74,37,0,712,718,3,202,101,0,713,714,3,74,37,
        0,714,715,3,202,101,0,715,717,1,0,0,0,716,713,1,0,0,0,717,720,1,
        0,0,0,718,716,1,0,0,0,718,719,1,0,0,0,719,722,1,0,0,0,720,718,1,
        0,0,0,721,711,1,0,0,0,721,722,1,0,0,0,722,723,1,0,0,0,723,727,5,
        16,0,0,724,726,5,131,0,0,725,724,1,0,0,0,726,729,1,0,0,0,727,725,
        1,0,0,0,727,728,1,0,0,0,728,43,1,0,0,0,729,727,1,0,0,0,730,734,5,
        36,0,0,731,733,5,131,0,0,732,731,1,0,0,0,733,736,1,0,0,0,734,732,
        1,0,0,0,734,735,1,0,0,0,735,737,1,0,0,0,736,734,1,0,0,0,737,739,
        3,194,97,0,738,740,3,62,31,0,739,738,1,0,0,0,739,740,1,0,0,0,740,
        751,1,0,0,0,741,745,5,120,0,0,742,744,5,131,0,0,743,742,1,0,0,0,
        744,747,1,0,0,0,745,743,1,0,0,0,745,746,1,0,0,0,746,750,1,0,0,0,
        747,745,1,0,0,0,748,750,3,198,99,0,749,741,1,0,0,0,749,748,1,0,0,
        0,750,753,1,0,0,0,751,749,1,0,0,0,751,752,1,0,0,0,752,756,1,0,0,
        0,753,751,1,0,0,0,754,757,3,202,101,0,755,757,3,94,47,0,756,754,
        1,0,0,0,756,755,1,0,0,0,757,45,1,0,0,0,758,776,3,194,97,0,759,763,
        5,22,0,0,760,762,5,131,0,0,761,760,1,0,0,0,762,765,1,0,0,0,763,761,
        1,0,0,0,763,764,1,0,0,0,764,767,1,0,0,0,765,763,1,0,0,0,766,768,
        3,144,72,0,767,766,1,0,0,0,767,768,1,0,0,0,768,769,1,0,0,0,769,773,
        5,23,0,0,770,772,5,131,0,0,771,770,1,0,0,0,772,775,1,0,0,0,773,771,
        1,0,0,0,773,774,1,0,0,0,774,777,1,0,0,0,775,773,1,0,0,0,776,759,
        1,0,0,0,776,777,1,0,0,0,777,47,1,0,0,0,778,779,3,50,25,0,779,780,
        3,62,31,0,780,782,3,54,27,0,781,783,3,52,26,0,782,781,1,0,0,0,782,
        783,1,0,0,0,783,786,1,0,0,0,784,787,3,202,101,0,785,787,3,94,47,
        0,786,784,1,0,0,0,786,785,1,0,0,0,787,49,1,0,0,0,788,792,5,37,0,
        0,789,791,5,131,0,0,790,789,1,0,0,0,791,794,1,0,0,0,792,790,1,0,
        0,0,792,793,1,0,0,0,793,796,1,0,0,0,794,792,1,0,0,0,795,797,3,194,
        97,0,796,795,1,0,0,0,796,797,1,0,0,0,797,820,1,0,0,0,798,802,5,125,
        0,0,799,801,5,131,0,0,800,799,1,0,0,0,801,804,1,0,0,0,802,800,1,
        0,0,0,802,803,1,0,0,0,803,820,1,0,0,0,804,802,1,0,0,0,805,809,5,
        126,0,0,806,808,5,131,0,0,807,806,1,0,0,0,808,811,1,0,0,0,809,807,
        1,0,0,0,809,810,1,0,0,0,810,820,1,0,0,0,811,809,1,0,0,0,812,816,
        5,127,0,0,813,815,5,131,0,0,814,813,1,0,0,0,815,818,1,0,0,0,816,
        814,1,0,0,0,816,817,1,0,0,0,817,820,1,0,0,0,818,816,1,0,0,0,819,
        788,1,0,0,0,819,798,1,0,0,0,819,805,1,0,0,0,819,812,1,0,0,0,820,
        51,1,0,0,0,821,825,5,38,0,0,822,824,5,131,0,0,823,822,1,0,0,0,824,
        827,1,0,0,0,825,823,1,0,0,0,825,826,1,0,0,0,826,828,1,0,0,0,827,
        825,1,0,0,0,828,829,3,62,31,0,829,53,1,0,0,0,830,834,5,114,0,0,831,
        833,5,131,0,0,832,831,1,0,0,0,833,836,1,0,0,0,834,832,1,0,0,0,834,
        835,1,0,0,0,835,869,1,0,0,0,836,834,1,0,0,0,837,841,5,119,0,0,838,
        840,5,131,0,0,839,838,1,0,0,0,840,843,1,0,0,0,841,839,1,0,0,0,841,
        842,1,0,0,0,842,869,1,0,0,0,843,841,1,0,0,0,844,848,5,116,0,0,845,
        847,5,131,0,0,846,845,1,0,0,0,847,850,1,0,0,0,848,846,1,0,0,0,848,
        849,1,0,0,0,849,869,1,0,0,0,850,848,1,0,0,0,851,855,5,118,0,0,852,
        854,5,131,0,0,853,852,1,0,0,0,854,857,1,0,0,0,855,853,1,0,0,0,855,
        856,1,0,0,0,856,869,1,0,0,0,857,855,1,0,0,0,858,862,5,120,0,0,859,
        861,5,131,0,0,860,859,1,0,0,0,861,864,1,0,0,0,862,860,1,0,0,0,862,
        863,1,0,0,0,863,869,1,0,0,0,864,862,1,0,0,0,865,869,3,92,46,0,866,
        869,3,46,23,0,867,869,3,198,99,0,868,830,1,0,0,0,868,837,1,0,0,0,
        868,844,1,0,0,0,868,851,1,0,0,0,868,858,1,0,0,0,868,865,1,0,0,0,
        868,866,1,0,0,0,868,867,1,0,0,0,869,872,1,0,0,0,870,868,1,0,0,0,
        870,871,1,0,0,0,871,55,1,0,0,0,872,870,1,0,0,0,873,877,5,39,0,0,
        874,876,5,131,0,0,875,874,1,0,0,0,876,879,1,0,0,0,877,875,1,0,0,
        0,877,878,1,0,0,0,878,880,1,0,0,0,879,877,1,0,0,0,880,881,3,194,
        97,0,881,889,3,66,33,0,882,886,5,108,0,0,883,885,5,131,0,0,884,883,
        1,0,0,0,885,888,1,0,0,0,886,884,1,0,0,0,886,887,1,0,0,0,887,890,
        1,0,0,0,888,886,1,0,0,0,889,882,1,0,0,0,889,890,1,0,0,0,890,891,
        1,0,0,0,891,892,3,202,101,0,892,57,1,0,0,0,893,894,3,194,97,0,894,
        59,1,0,0,0,895,899,5,40,0,0,896,898,5,131,0,0,897,896,1,0,0,0,898,
        901,1,0,0,0,899,897,1,0,0,0,899,900,1,0,0,0,900,902,1,0,0,0,901,
        899,1,0,0,0,902,903,3,194,97,0,903,907,5,14,0,0,904,906,5,131,0,
        0,905,904,1,0,0,0,906,909,1,0,0,0,907,905,1,0,0,0,907,908,1,0,0,
        0,908,911,1,0,0,0,909,907,1,0,0,0,910,912,3,58,29,0,911,910,1,0,
        0,0,911,912,1,0,0,0,912,923,1,0,0,0,913,917,5,15,0,0,914,916,5,131,
        0,0,915,914,1,0,0,0,916,919,1,0,0,0,917,915,1,0,0,0,917,918,1,0,
        0,0,918,920,1,0,0,0,919,917,1,0,0,0,920,922,3,58,29,0,921,913,1,
        0,0,0,922,925,1,0,0,0,923,921,1,0,0,0,923,924,1,0,0,0,924,926,1,
        0,0,0,925,923,1,0,0,0,926,930,5,16,0,0,927,929,5,131,0,0,928,927,
        1,0,0,0,929,932,1,0,0,0,930,928,1,0,0,0,930,931,1,0,0,0,931,61,1,
        0,0,0,932,930,1,0,0,0,933,937,5,22,0,0,934,936,5,131,0,0,935,934,
        1,0,0,0,936,939,1,0,0,0,937,935,1,0,0,0,937,938,1,0,0,0,938,954,
        1,0,0,0,939,937,1,0,0,0,940,951,3,64,32,0,941,945,5,15,0,0,942,944,
        5,131,0,0,943,942,1,0,0,0,944,947,1,0,0,0,945,943,1,0,0,0,945,946,
        1,0,0,0,946,948,1,0,0,0,947,945,1,0,0,0,948,950,3,64,32,0,949,941,
        1,0,0,0,950,953,1,0,0,0,951,949,1,0,0,0,951,952,1,0,0,0,952,955,
        1,0,0,0,953,951,1,0,0,0,954,940,1,0,0,0,954,955,1,0,0,0,955,956,
        1,0,0,0,956,960,5,23,0,0,957,959,5,131,0,0,958,957,1,0,0,0,959,962,
        1,0,0,0,960,958,1,0,0,0,960,961,1,0,0,0,961,63,1,0,0,0,962,960,1,
        0,0,0,963,965,3,76,38,0,964,966,3,90,45,0,965,964,1,0,0,0,965,966,
        1,0,0,0,966,968,1,0,0,0,967,969,3,194,97,0,968,967,1,0,0,0,968,969,
        1,0,0,0,969,65,1,0,0,0,970,974,5,22,0,0,971,973,5,131,0,0,972,971,
        1,0,0,0,973,976,1,0,0,0,974,972,1,0,0,0,974,975,1,0,0,0,975,991,
        1,0,0,0,976,974,1,0,0,0,977,988,3,68,34,0,978,982,5,15,0,0,979,981,
        5,131,0,0,980,979,1,0,0,0,981,984,1,0,0,0,982,980,1,0,0,0,982,983,
        1,0,0,0,983,985,1,0,0,0,984,982,1,0,0,0,985,987,3,68,34,0,986,978,
        1,0,0,0,987,990,1,0,0,0,988,986,1,0,0,0,988,989,1,0,0,0,989,992,
        1,0,0,0,990,988,1,0,0,0,991,977,1,0,0,0,991,992,1,0,0,0,992,993,
        1,0,0,0,993,997,5,23,0,0,994,996,5,131,0,0,995,994,1,0,0,0,996,999,
        1,0,0,0,997,995,1,0,0,0,997,998,1,0,0,0,998,67,1,0,0,0,999,997,1,
        0,0,0,1000,1008,3,76,38,0,1001,1005,5,115,0,0,1002,1004,5,131,0,
        0,1003,1002,1,0,0,0,1004,1007,1,0,0,0,1005,1003,1,0,0,0,1005,1006,
        1,0,0,0,1006,1009,1,0,0,0,1007,1005,1,0,0,0,1008,1001,1,0,0,0,1008,
        1009,1,0,0,0,1009,1011,1,0,0,0,1010,1012,3,194,97,0,1011,1010,1,
        0,0,0,1011,1012,1,0,0,0,1012,69,1,0,0,0,1013,1017,5,22,0,0,1014,
        1016,5,131,0,0,1015,1014,1,0,0,0,1016,1019,1,0,0,0,1017,1015,1,0,
        0,0,1017,1018,1,0,0,0,1018,1034,1,0,0,0,1019,1017,1,0,0,0,1020,1031,
        3,72,36,0,1021,1025,5,15,0,0,1022,1024,5,131,0,0,1023,1022,1,0,0,
        0,1024,1027,1,0,0,0,1025,1023,1,0,0,0,1025,1026,1,0,0,0,1026,1028,
        1,0,0,0,1027,1025,1,0,0,0,1028,1030,3,72,36,0,1029,1021,1,0,0,0,
        1030,1033,1,0,0,0,1031,1029,1,0,0,0,1031,1032,1,0,0,0,1032,1035,
        1,0,0,0,1033,1031,1,0,0,0,1034,1020,1,0,0,0,1034,1035,1,0,0,0,1035,
        1036,1,0,0,0,1036,1040,5,23,0,0,1037,1039,5,131,0,0,1038,1037,1,
        0,0,0,1039,1042,1,0,0,0,1040,1038,1,0,0,0,1040,1041,1,0,0,0,1041,
        71,1,0,0,0,1042,1040,1,0,0,0,1043,1045,3,76,38,0,1044,1046,3,90,
        45,0,1045,1044,1,0,0,0,1045,1046,1,0,0,0,1046,73,1,0,0,0,1047,1049,
        3,76,38,0,1048,1050,3,90,45,0,1049,1048,1,0,0,0,1049,1050,1,0,0,
        0,1050,1051,1,0,0,0,1051,1052,3,194,97,0,1052,75,1,0,0,0,1053,1054,
        6,38,-1,0,1054,1073,3,138,69,0,1055,1073,3,78,39,0,1056,1073,3,82,
        41,0,1057,1073,3,88,44,0,1058,1062,5,43,0,0,1059,1061,5,131,0,0,
        1060,1059,1,0,0,0,1061,1064,1,0,0,0,1062,1060,1,0,0,0,1062,1063,
        1,0,0,0,1063,1065,1,0,0,0,1064,1062,1,0,0,0,1065,1069,5,117,0,0,
        1066,1068,5,131,0,0,1067,1066,1,0,0,0,1068,1071,1,0,0,0,1069,1067,
        1,0,0,0,1069,1070,1,0,0,0,1070,1073,1,0,0,0,1071,1069,1,0,0,0,1072,
        1053,1,0,0,0,1072,1055,1,0,0,0,1072,1056,1,0,0,0,1072,1057,1,0,0,
        0,1072,1058,1,0,0,0,1073,1094,1,0,0,0,1074,1075,10,3,0,0,1075,1079,
        5,41,0,0,1076,1078,5,131,0,0,1077,1076,1,0,0,0,1078,1081,1,0,0,0,
        1079,1077,1,0,0,0,1079,1080,1,0,0,0,1080,1083,1,0,0,0,1081,1079,
        1,0,0,0,1082,1084,3,140,70,0,1083,1082,1,0,0,0,1083,1084,1,0,0,0,
        1084,1085,1,0,0,0,1085,1089,5,42,0,0,1086,1088,5,131,0,0,1087,1086,
        1,0,0,0,1088,1091,1,0,0,0,1089,1087,1,0,0,0,1089,1090,1,0,0,0,1090,
        1093,1,0,0,0,1091,1089,1,0,0,0,1092,1074,1,0,0,0,1093,1096,1,0,0,
        0,1094,1092,1,0,0,0,1094,1095,1,0,0,0,1095,77,1,0,0,0,1096,1094,
        1,0,0,0,1097,1108,3,194,97,0,1098,1102,5,44,0,0,1099,1101,5,131,
        0,0,1100,1099,1,0,0,0,1101,1104,1,0,0,0,1102,1100,1,0,0,0,1102,1103,
        1,0,0,0,1103,1105,1,0,0,0,1104,1102,1,0,0,0,1105,1107,3,194,97,0,
        1106,1098,1,0,0,0,1107,1110,1,0,0,0,1108,1106,1,0,0,0,1108,1109,
        1,0,0,0,1109,79,1,0,0,0,1110,1108,1,0,0,0,1111,1114,3,138,69,0,1112,
        1114,3,78,39,0,1113,1111,1,0,0,0,1113,1112,1,0,0,0,1114,81,1,0,0,
        0,1115,1119,5,45,0,0,1116,1118,5,131,0,0,1117,1116,1,0,0,0,1118,
        1121,1,0,0,0,1119,1117,1,0,0,0,1119,1120,1,0,0,0,1120,1122,1,0,0,
        0,1121,1119,1,0,0,0,1122,1126,5,22,0,0,1123,1125,5,131,0,0,1124,
        1123,1,0,0,0,1125,1128,1,0,0,0,1126,1124,1,0,0,0,1126,1127,1,0,0,
        0,1127,1129,1,0,0,0,1128,1126,1,0,0,0,1129,1131,3,80,40,0,1130,1132,
        3,84,42,0,1131,1130,1,0,0,0,1131,1132,1,0,0,0,1132,1133,1,0,0,0,
        1133,1137,5,46,0,0,1134,1136,5,131,0,0,1135,1134,1,0,0,0,1136,1139,
        1,0,0,0,1137,1135,1,0,0,0,1137,1138,1,0,0,0,1138,1140,1,0,0,0,1139,
        1137,1,0,0,0,1140,1142,3,76,38,0,1141,1143,3,86,43,0,1142,1141,1,
        0,0,0,1142,1143,1,0,0,0,1143,1144,1,0,0,0,1144,1148,5,23,0,0,1145,
        1147,5,131,0,0,1146,1145,1,0,0,0,1147,1150,1,0,0,0,1148,1146,1,0,
        0,0,1148,1149,1,0,0,0,1149,83,1,0,0,0,1150,1148,1,0,0,0,1151,1152,
        3,194,97,0,1152,85,1,0,0,0,1153,1154,3,194,97,0,1154,87,1,0,0,0,
        1155,1159,5,37,0,0,1156,1158,5,131,0,0,1157,1156,1,0,0,0,1158,1161,
        1,0,0,0,1159,1157,1,0,0,0,1159,1160,1,0,0,0,1160,1162,1,0,0,0,1161,
        1159,1,0,0,0,1162,1180,3,70,35,0,1163,1167,5,116,0,0,1164,1166,5,
        131,0,0,1165,1164,1,0,0,0,1166,1169,1,0,0,0,1167,1165,1,0,0,0,1167,
        1168,1,0,0,0,1168,1179,1,0,0,0,1169,1167,1,0,0,0,1170,1174,5,114,
        0,0,1171,1173,5,131,0,0,1172,1171,1,0,0,0,1173,1176,1,0,0,0,1174,
        1172,1,0,0,0,1174,1175,1,0,0,0,1175,1179,1,0,0,0,1176,1174,1,0,0,
        0,1177,1179,3,92,46,0,1178,1163,1,0,0,0,1178,1170,1,0,0,0,1178,1177,
        1,0,0,0,1179,1182,1,0,0,0,1180,1178,1,0,0,0,1180,1181,1,0,0,0,1181,
        1191,1,0,0,0,1182,1180,1,0,0,0,1183,1187,5,38,0,0,1184,1186,5,131,
        0,0,1185,1184,1,0,0,0,1186,1189,1,0,0,0,1187,1185,1,0,0,0,1187,1188,
        1,0,0,0,1188,1190,1,0,0,0,1189,1187,1,0,0,0,1190,1192,3,70,35,0,
        1191,1183,1,0,0,0,1191,1192,1,0,0,0,1192,89,1,0,0,0,1193,1197,7,
        3,0,0,1194,1196,5,131,0,0,1195,1194,1,0,0,0,1196,1199,1,0,0,0,1197,
        1195,1,0,0,0,1197,1198,1,0,0,0,1198,91,1,0,0,0,1199,1197,1,0,0,0,
        1200,1204,7,4,0,0,1201,1203,5,131,0,0,1202,1201,1,0,0,0,1203,1206,
        1,0,0,0,1204,1202,1,0,0,0,1204,1205,1,0,0,0,1205,93,1,0,0,0,1206,
        1204,1,0,0,0,1207,1211,5,14,0,0,1208,1210,5,131,0,0,1209,1208,1,
        0,0,0,1210,1213,1,0,0,0,1211,1209,1,0,0,0,1211,1212,1,0,0,0,1212,
        1217,1,0,0,0,1213,1211,1,0,0,0,1214,1216,3,96,48,0,1215,1214,1,0,
        0,0,1216,1219,1,0,0,0,1217,1215,1,0,0,0,1217,1218,1,0,0,0,1218,1220,
        1,0,0,0,1219,1217,1,0,0,0,1220,1224,5,16,0,0,1221,1223,5,131,0,0,
        1222,1221,1,0,0,0,1223,1226,1,0,0,0,1224,1222,1,0,0,0,1224,1225,
        1,0,0,0,1225,95,1,0,0,0,1226,1224,1,0,0,0,1227,1243,3,100,50,0,1228,
        1243,3,102,51,0,1229,1243,3,106,53,0,1230,1243,3,112,56,0,1231,1243,
        3,94,47,0,1232,1243,3,114,57,0,1233,1243,3,118,59,0,1234,1243,3,
        120,60,0,1235,1243,3,122,61,0,1236,1243,3,124,62,0,1237,1243,3,126,
        63,0,1238,1243,3,128,64,0,1239,1243,3,108,54,0,1240,1243,3,110,55,
        0,1241,1243,3,130,65,0,1242,1227,1,0,0,0,1242,1228,1,0,0,0,1242,
        1229,1,0,0,0,1242,1230,1,0,0,0,1242,1231,1,0,0,0,1242,1232,1,0,0,
        0,1242,1233,1,0,0,0,1242,1234,1,0,0,0,1242,1235,1,0,0,0,1242,1236,
        1,0,0,0,1242,1237,1,0,0,0,1242,1238,1,0,0,0,1242,1239,1,0,0,0,1242,
        1240,1,0,0,0,1242,1241,1,0,0,0,1243,97,1,0,0,0,1244,1245,3,140,70,
        0,1245,1246,3,202,101,0,1246,99,1,0,0,0,1247,1251,5,50,0,0,1248,
        1250,5,131,0,0,1249,1248,1,0,0,0,1250,1253,1,0,0,0,1251,1249,1,0,
        0,0,1251,1252,1,0,0,0,1252,1254,1,0,0,0,1253,1251,1,0,0,0,1254,1258,
        5,22,0,0,1255,1257,5,131,0,0,1256,1255,1,0,0,0,1257,1260,1,0,0,0,
        1258,1256,1,0,0,0,1258,1259,1,0,0,0,1259,1261,1,0,0,0,1260,1258,
        1,0,0,0,1261,1262,3,140,70,0,1262,1266,5,23,0,0,1263,1265,5,131,
        0,0,1264,1263,1,0,0,0,1265,1268,1,0,0,0,1266,1264,1,0,0,0,1266,1267,
        1,0,0,0,1267,1269,1,0,0,0,1268,1266,1,0,0,0,1269,1278,3,96,48,0,
        1270,1274,5,51,0,0,1271,1273,5,131,0,0,1272,1271,1,0,0,0,1273,1276,
        1,0,0,0,1274,1272,1,0,0,0,1274,1275,1,0,0,0,1275,1277,1,0,0,0,1276,
        1274,1,0,0,0,1277,1279,3,96,48,0,1278,1270,1,0,0,0,1278,1279,1,0,
        0,0,1279,101,1,0,0,0,1280,1284,5,52,0,0,1281,1283,5,131,0,0,1282,
        1281,1,0,0,0,1283,1286,1,0,0,0,1284,1282,1,0,0,0,1284,1285,1,0,0,
        0,1285,1287,1,0,0,0,1286,1284,1,0,0,0,1287,1289,3,140,70,0,1288,
        1290,3,52,26,0,1289,1288,1,0,0,0,1289,1290,1,0,0,0,1290,1291,1,0,
        0,0,1291,1293,3,94,47,0,1292,1294,3,104,52,0,1293,1292,1,0,0,0,1294,
        1295,1,0,0,0,1295,1293,1,0,0,0,1295,1296,1,0,0,0,1296,103,1,0,0,
        0,1297,1301,5,53,0,0,1298,1300,5,131,0,0,1299,1298,1,0,0,0,1300,
        1303,1,0,0,0,1301,1299,1,0,0,0,1301,1302,1,0,0,0,1302,1308,1,0,0,
        0,1303,1301,1,0,0,0,1304,1306,3,194,97,0,1305,1304,1,0,0,0,1305,
        1306,1,0,0,0,1306,1307,1,0,0,0,1307,1309,3,62,31,0,1308,1305,1,0,
        0,0,1308,1309,1,0,0,0,1309,1310,1,0,0,0,1310,1311,3,94,47,0,1311,
        105,1,0,0,0,1312,1316,5,54,0,0,1313,1315,5,131,0,0,1314,1313,1,0,
        0,0,1315,1318,1,0,0,0,1316,1314,1,0,0,0,1316,1317,1,0,0,0,1317,1319,
        1,0,0,0,1318,1316,1,0,0,0,1319,1323,5,22,0,0,1320,1322,5,131,0,0,
        1321,1320,1,0,0,0,1322,1325,1,0,0,0,1323,1321,1,0,0,0,1323,1324,
        1,0,0,0,1324,1326,1,0,0,0,1325,1323,1,0,0,0,1326,1327,3,140,70,0,
        1327,1331,5,23,0,0,1328,1330,5,131,0,0,1329,1328,1,0,0,0,1330,1333,
        1,0,0,0,1331,1329,1,0,0,0,1331,1332,1,0,0,0,1332,1334,1,0,0,0,1333,
        1331,1,0,0,0,1334,1335,3,96,48,0,1335,107,1,0,0,0,1336,1339,3,132,
        66,0,1337,1339,3,98,49,0,1338,1336,1,0,0,0,1338,1337,1,0,0,0,1339,
        109,1,0,0,0,1340,1344,5,55,0,0,1341,1343,5,131,0,0,1342,1341,1,0,
        0,0,1343,1346,1,0,0,0,1344,1342,1,0,0,0,1344,1345,1,0,0,0,1345,1347,
        1,0,0,0,1346,1344,1,0,0,0,1347,1348,3,94,47,0,1348,111,1,0,0,0,1349,
        1353,5,26,0,0,1350,1352,5,131,0,0,1351,1350,1,0,0,0,1352,1355,1,
        0,0,0,1353,1351,1,0,0,0,1353,1354,1,0,0,0,1354,1356,1,0,0,0,1355,
        1353,1,0,0,0,1356,1360,5,22,0,0,1357,1359,5,131,0,0,1358,1357,1,
        0,0,0,1359,1362,1,0,0,0,1360,1358,1,0,0,0,1360,1361,1,0,0,0,1361,
        1371,1,0,0,0,1362,1360,1,0,0,0,1363,1372,3,108,54,0,1364,1368,5,
        56,0,0,1365,1367,5,131,0,0,1366,1365,1,0,0,0,1367,1370,1,0,0,0,1368,
        1366,1,0,0,0,1368,1369,1,0,0,0,1369,1372,1,0,0,0,1370,1368,1,0,0,
        0,1371,1363,1,0,0,0,1371,1364,1,0,0,0,1372,1381,1,0,0,0,1373,1382,
        3,98,49,0,1374,1378,5,56,0,0,1375,1377,5,131,0,0,1376,1375,1,0,0,
        0,1377,1380,1,0,0,0,1378,1376,1,0,0,0,1378,1379,1,0,0,0,1379,1382,
        1,0,0,0,1380,1378,1,0,0,0,1381,1373,1,0,0,0,1381,1374,1,0,0,0,1382,
        1384,1,0,0,0,1383,1385,3,140,70,0,1384,1383,1,0,0,0,1384,1385,1,
        0,0,0,1385,1386,1,0,0,0,1386,1390,5,23,0,0,1387,1389,5,131,0,0,1388,
        1387,1,0,0,0,1389,1392,1,0,0,0,1390,1388,1,0,0,0,1390,1391,1,0,0,
        0,1391,1393,1,0,0,0,1392,1390,1,0,0,0,1393,1394,3,96,48,0,1394,113,
        1,0,0,0,1395,1399,5,57,0,0,1396,1398,5,131,0,0,1397,1396,1,0,0,0,
        1398,1401,1,0,0,0,1399,1397,1,0,0,0,1399,1400,1,0,0,0,1400,1409,
        1,0,0,0,1401,1399,1,0,0,0,1402,1406,5,129,0,0,1403,1405,5,131,0,
        0,1404,1403,1,0,0,0,1405,1408,1,0,0,0,1406,1404,1,0,0,0,1406,1407,
        1,0,0,0,1407,1410,1,0,0,0,1408,1406,1,0,0,0,1409,1402,1,0,0,0,1409,
        1410,1,0,0,0,1410,1426,1,0,0,0,1411,1415,5,22,0,0,1412,1414,5,131,
        0,0,1413,1412,1,0,0,0,1414,1417,1,0,0,0,1415,1413,1,0,0,0,1415,1416,
        1,0,0,0,1416,1418,1,0,0,0,1417,1415,1,0,0,0,1418,1419,3,116,58,0,
        1419,1423,5,23,0,0,1420,1422,5,131,0,0,1421,1420,1,0,0,0,1422,1425,
        1,0,0,0,1423,1421,1,0,0,0,1423,1424,1,0,0,0,1424,1427,1,0,0,0,1425,
        1423,1,0,0,0,1426,1411,1,0,0,0,1426,1427,1,0,0,0,1427,1428,1,0,0,
        0,1428,1429,3,154,77,0,1429,115,1,0,0,0,1430,1431,3,200,100,0,1431,
        117,1,0,0,0,1432,1436,5,58,0,0,1433,1435,5,131,0,0,1434,1433,1,0,
        0,0,1435,1438,1,0,0,0,1436,1434,1,0,0,0,1436,1437,1,0,0,0,1437,1439,
        1,0,0,0,1438,1436,1,0,0,0,1439,1440,3,96,48,0,1440,1444,5,54,0,0,
        1441,1443,5,131,0,0,1442,1441,1,0,0,0,1443,1446,1,0,0,0,1444,1442,
        1,0,0,0,1444,1445,1,0,0,0,1445,1447,1,0,0,0,1446,1444,1,0,0,0,1447,
        1451,5,22,0,0,1448,1450,5,131,0,0,1449,1448,1,0,0,0,1450,1453,1,
        0,0,0,1451,1449,1,0,0,0,1451,1452,1,0,0,0,1452,1454,1,0,0,0,1453,
        1451,1,0,0,0,1454,1455,3,140,70,0,1455,1456,5,23,0,0,1456,1457,3,
        202,101,0,1457,119,1,0,0,0,1458,1459,5,112,0,0,1459,1460,3,202,101,
        0,1460,121,1,0,0,0,1461,1462,5,109,0,0,1462,1463,3,202,101,0,1463,
        123,1,0,0,0,1464,1468,5,59,0,0,1465,1467,5,131,0,0,1466,1465,1,0,
        0,0,1467,1470,1,0,0,0,1468,1466,1,0,0,0,1468,1469,1,0,0,0,1469,1472,
        1,0,0,0,1470,1468,1,0,0,0,1471,1473,3,140,70,0,1472,1471,1,0,0,0,
        1472,1473,1,0,0,0,1473,1474,1,0,0,0,1474,1475,3,202,101,0,1475,125,
        1,0,0,0,1476,1477,5,60,0,0,1477,1478,3,202,101,0,1478,127,1,0,0,
        0,1479,1483,5,61,0,0,1480,1482,5,131,0,0,1481,1480,1,0,0,0,1482,
        1485,1,0,0,0,1483,1481,1,0,0,0,1483,1484,1,0,0,0,1484,1486,1,0,0,
        0,1485,1483,1,0,0,0,1486,1487,3,152,76,0,1487,1488,3,202,101,0,1488,
        129,1,0,0,0,1489,1493,5,62,0,0,1490,1492,5,131,0,0,1491,1490,1,0,
        0,0,1492,1495,1,0,0,0,1493,1491,1,0,0,0,1493,1494,1,0,0,0,1494,1496,
        1,0,0,0,1495,1493,1,0,0,0,1496,1497,3,152,76,0,1497,1498,3,202,101,
        0,1498,131,1,0,0,0,1499,1503,5,63,0,0,1500,1502,5,131,0,0,1501,1500,
        1,0,0,0,1502,1505,1,0,0,0,1503,1501,1,0,0,0,1503,1504,1,0,0,0,1504,
        1506,1,0,0,0,1505,1503,1,0,0,0,1506,1524,3,136,68,0,1507,1524,3,
        74,37,0,1508,1512,5,22,0,0,1509,1511,5,131,0,0,1510,1509,1,0,0,0,
        1511,1514,1,0,0,0,1512,1510,1,0,0,0,1512,1513,1,0,0,0,1513,1515,
        1,0,0,0,1514,1512,1,0,0,0,1515,1516,3,134,67,0,1516,1520,5,23,0,
        0,1517,1519,5,131,0,0,1518,1517,1,0,0,0,1519,1522,1,0,0,0,1520,1518,
        1,0,0,0,1520,1521,1,0,0,0,1521,1524,1,0,0,0,1522,1520,1,0,0,0,1523,
        1499,1,0,0,0,1523,1507,1,0,0,0,1523,1508,1,0,0,0,1524,1533,1,0,0,
        0,1525,1529,5,10,0,0,1526,1528,5,131,0,0,1527,1526,1,0,0,0,1528,
        1531,1,0,0,0,1529,1527,1,0,0,0,1529,1530,1,0,0,0,1530,1532,1,0,0,
        0,1531,1529,1,0,0,0,1532,1534,3,140,70,0,1533,1525,1,0,0,0,1533,
        1534,1,0,0,0,1534,1535,1,0,0,0,1535,1536,3,202,101,0,1536,133,1,
        0,0,0,1537,1539,3,74,37,0,1538,1537,1,0,0,0,1538,1539,1,0,0,0,1539,
        1552,1,0,0,0,1540,1544,5,15,0,0,1541,1543,5,131,0,0,1542,1541,1,
        0,0,0,1543,1546,1,0,0,0,1544,1542,1,0,0,0,1544,1545,1,0,0,0,1545,
        1548,1,0,0,0,1546,1544,1,0,0,0,1547,1549,3,74,37,0,1548,1547,1,0,
        0,0,1548,1549,1,0,0,0,1549,1551,1,0,0,0,1550,1540,1,0,0,0,1551,1554,
        1,0,0,0,1552,1550,1,0,0,0,1552,1553,1,0,0,0,1553,135,1,0,0,0,1554,
        1552,1,0,0,0,1555,1559,5,22,0,0,1556,1558,5,131,0,0,1557,1556,1,
        0,0,0,1558,1561,1,0,0,0,1559,1557,1,0,0,0,1559,1560,1,0,0,0,1560,
        1574,1,0,0,0,1561,1559,1,0,0,0,1562,1564,3,194,97,0,1563,1562,1,
        0,0,0,1563,1564,1,0,0,0,1564,1565,1,0,0,0,1565,1569,5,15,0,0,1566,
        1568,5,131,0,0,1567,1566,1,0,0,0,1568,1571,1,0,0,0,1569,1567,1,0,
        0,0,1569,1570,1,0,0,0,1570,1573,1,0,0,0,1571,1569,1,0,0,0,1572,1563,
        1,0,0,0,1573,1576,1,0,0,0,1574,1572,1,0,0,0,1574,1575,1,0,0,0,1575,
        1578,1,0,0,0,1576,1574,1,0,0,0,1577,1579,3,194,97,0,1578,1577,1,
        0,0,0,1578,1579,1,0,0,0,1579,1580,1,0,0,0,1580,1584,5,23,0,0,1581,
        1583,5,131,0,0,1582,1581,1,0,0,0,1583,1586,1,0,0,0,1584,1582,1,0,
        0,0,1584,1585,1,0,0,0,1585,137,1,0,0,0,1586,1584,1,0,0,0,1587,1591,
        7,5,0,0,1588,1590,5,131,0,0,1589,1588,1,0,0,0,1590,1593,1,0,0,0,
        1591,1589,1,0,0,0,1591,1592,1,0,0,0,1592,139,1,0,0,0,1593,1591,1,
        0,0,0,1594,1595,6,70,-1,0,1595,1599,5,69,0,0,1596,1598,5,131,0,0,
        1597,1596,1,0,0,0,1598,1601,1,0,0,0,1599,1597,1,0,0,0,1599,1600,
        1,0,0,0,1600,1602,1,0,0,0,1601,1599,1,0,0,0,1602,1660,3,76,38,0,
        1603,1607,5,22,0,0,1604,1606,5,131,0,0,1605,1604,1,0,0,0,1606,1609,
        1,0,0,0,1607,1605,1,0,0,0,1607,1608,1,0,0,0,1608,1610,1,0,0,0,1609,
        1607,1,0,0,0,1610,1611,3,140,70,0,1611,1615,5,23,0,0,1612,1614,5,
        131,0,0,1613,1612,1,0,0,0,1614,1617,1,0,0,0,1615,1613,1,0,0,0,1615,
        1616,1,0,0,0,1616,1660,1,0,0,0,1617,1615,1,0,0,0,1618,1622,7,6,0,
        0,1619,1621,5,131,0,0,1620,1619,1,0,0,0,1621,1624,1,0,0,0,1622,1620,
        1,0,0,0,1622,1623,1,0,0,0,1623,1625,1,0,0,0,1624,1622,1,0,0,0,1625,
        1660,3,140,70,19,1626,1630,7,7,0,0,1627,1629,5,131,0,0,1628,1627,
        1,0,0,0,1629,1632,1,0,0,0,1630,1628,1,0,0,0,1630,1631,1,0,0,0,1631,
        1633,1,0,0,0,1632,1630,1,0,0,0,1633,1660,3,140,70,18,1634,1638,5,
        71,0,0,1635,1637,5,131,0,0,1636,1635,1,0,0,0,1637,1640,1,0,0,0,1638,
        1636,1,0,0,0,1638,1639,1,0,0,0,1639,1641,1,0,0,0,1640,1638,1,0,0,
        0,1641,1660,3,140,70,17,1642,1646,5,72,0,0,1643,1645,5,131,0,0,1644,
        1643,1,0,0,0,1645,1648,1,0,0,0,1646,1644,1,0,0,0,1646,1647,1,0,0,
        0,1647,1649,1,0,0,0,1648,1646,1,0,0,0,1649,1660,3,140,70,16,1650,
        1654,5,5,0,0,1651,1653,5,131,0,0,1652,1651,1,0,0,0,1653,1656,1,0,
        0,0,1654,1652,1,0,0,0,1654,1655,1,0,0,0,1655,1657,1,0,0,0,1656,1654,
        1,0,0,0,1657,1660,3,140,70,15,1658,1660,3,142,71,0,1659,1594,1,0,
        0,0,1659,1603,1,0,0,0,1659,1618,1,0,0,0,1659,1626,1,0,0,0,1659,1634,
        1,0,0,0,1659,1642,1,0,0,0,1659,1650,1,0,0,0,1659,1658,1,0,0,0,1660,
        1882,1,0,0,0,1661,1662,10,14,0,0,1662,1666,5,73,0,0,1663,1665,5,
        131,0,0,1664,1663,1,0,0,0,1665,1668,1,0,0,0,1666,1664,1,0,0,0,1666,
        1667,1,0,0,0,1667,1669,1,0,0,0,1668,1666,1,0,0,0,1669,1881,3,140,
        70,15,1670,1671,10,13,0,0,1671,1675,7,8,0,0,1672,1674,5,131,0,0,
        1673,1672,1,0,0,0,1674,1677,1,0,0,0,1675,1673,1,0,0,0,1675,1676,
        1,0,0,0,1676,1678,1,0,0,0,1677,1675,1,0,0,0,1678,1881,3,140,70,14,
        1679,1680,10,12,0,0,1680,1684,7,7,0,0,1681,1683,5,131,0,0,1682,1681,
        1,0,0,0,1683,1686,1,0,0,0,1684,1682,1,0,0,0,1684,1685,1,0,0,0,1685,
        1687,1,0,0,0,1686,1684,1,0,0,0,1687,1881,3,140,70,13,1688,1689,10,
        11,0,0,1689,1693,7,9,0,0,1690,1692,5,131,0,0,1691,1690,1,0,0,0,1692,
        1695,1,0,0,0,1693,1691,1,0,0,0,1693,1694,1,0,0,0,1694,1696,1,0,0,
        0,1695,1693,1,0,0,0,1696,1881,3,140,70,12,1697,1698,10,10,0,0,1698,
        1702,5,28,0,0,1699,1701,5,131,0,0,1700,1699,1,0,0,0,1701,1704,1,
        0,0,0,1702,1700,1,0,0,0,1702,1703,1,0,0,0,1703,1705,1,0,0,0,1704,
        1702,1,0,0,0,1705,1881,3,140,70,11,1706,1707,10,9,0,0,1707,1711,
        5,4,0,0,1708,1710,5,131,0,0,1709,1708,1,0,0,0,1710,1713,1,0,0,0,
        1711,1709,1,0,0,0,1711,1712,1,0,0,0,1712,1714,1,0,0,0,1713,1711,
        1,0,0,0,1714,1881,3,140,70,10,1715,1716,10,8,0,0,1716,1720,5,27,
        0,0,1717,1719,5,131,0,0,1718,1717,1,0,0,0,1719,1722,1,0,0,0,1720,
        1718,1,0,0,0,1720,1721,1,0,0,0,1721,1723,1,0,0,0,1722,1720,1,0,0,
        0,1723,1881,3,140,70,9,1724,1725,10,7,0,0,1725,1729,7,10,0,0,1726,
        1728,5,131,0,0,1727,1726,1,0,0,0,1728,1731,1,0,0,0,1729,1727,1,0,
        0,0,1729,1730,1,0,0,0,1730,1732,1,0,0,0,1731,1729,1,0,0,0,1732,1881,
        3,140,70,8,1733,1734,10,6,0,0,1734,1738,7,11,0,0,1735,1737,5,131,
        0,0,1736,1735,1,0,0,0,1737,1740,1,0,0,0,1738,1736,1,0,0,0,1738,1739,
        1,0,0,0,1739,1741,1,0,0,0,1740,1738,1,0,0,0,1741,1881,3,140,70,7,
        1742,1743,10,5,0,0,1743,1747,5,76,0,0,1744,1746,5,131,0,0,1745,1744,
        1,0,0,0,1746,1749,1,0,0,0,1747,1745,1,0,0,0,1747,1748,1,0,0,0,1748,
        1750,1,0,0,0,1749,1747,1,0,0,0,1750,1881,3,140,70,6,1751,1752,10,
        4,0,0,1752,1756,5,3,0,0,1753,1755,5,131,0,0,1754,1753,1,0,0,0,1755,
        1758,1,0,0,0,1756,1754,1,0,0,0,1756,1757,1,0,0,0,1757,1759,1,0,0,
        0,1758,1756,1,0,0,0,1759,1881,3,140,70,5,1760,1761,10,3,0,0,1761,
        1765,5,77,0,0,1762,1764,5,131,0,0,1763,1762,1,0,0,0,1764,1767,1,
        0,0,0,1765,1763,1,0,0,0,1765,1766,1,0,0,0,1766,1768,1,0,0,0,1767,
        1765,1,0,0,0,1768,1769,3,140,70,0,1769,1773,5,70,0,0,1770,1772,5,
        131,0,0,1771,1770,1,0,0,0,1772,1775,1,0,0,0,1773,1771,1,0,0,0,1773,
        1774,1,0,0,0,1774,1776,1,0,0,0,1775,1773,1,0,0,0,1776,1777,3,140,
        70,4,1777,1881,1,0,0,0,1778,1779,10,2,0,0,1779,1783,7,12,0,0,1780,
        1782,5,131,0,0,1781,1780,1,0,0,0,1782,1785,1,0,0,0,1783,1781,1,0,
        0,0,1783,1784,1,0,0,0,1784,1786,1,0,0,0,1785,1783,1,0,0,0,1786,1881,
        3,140,70,3,1787,1788,10,27,0,0,1788,1792,7,6,0,0,1789,1791,5,131,
        0,0,1790,1789,1,0,0,0,1791,1794,1,0,0,0,1792,1790,1,0,0,0,1792,1793,
        1,0,0,0,1793,1881,1,0,0,0,1794,1792,1,0,0,0,1795,1796,10,25,0,0,
        1796,1800,5,41,0,0,1797,1799,5,131,0,0,1798,1797,1,0,0,0,1799,1802,
        1,0,0,0,1800,1798,1,0,0,0,1800,1801,1,0,0,0,1801,1803,1,0,0,0,1802,
        1800,1,0,0,0,1803,1804,3,140,70,0,1804,1808,5,42,0,0,1805,1807,5,
        131,0,0,1806,1805,1,0,0,0,1807,1810,1,0,0,0,1808,1806,1,0,0,0,1808,
        1809,1,0,0,0,1809,1881,1,0,0,0,1810,1808,1,0,0,0,1811,1812,10,24,
        0,0,1812,1816,5,41,0,0,1813,1815,5,131,0,0,1814,1813,1,0,0,0,1815,
        1818,1,0,0,0,1816,1814,1,0,0,0,1816,1817,1,0,0,0,1817,1820,1,0,0,
        0,1818,1816,1,0,0,0,1819,1821,3,140,70,0,1820,1819,1,0,0,0,1820,
        1821,1,0,0,0,1821,1822,1,0,0,0,1822,1826,5,70,0,0,1823,1825,5,131,
        0,0,1824,1823,1,0,0,0,1825,1828,1,0,0,0,1826,1824,1,0,0,0,1826,1827,
        1,0,0,0,1827,1830,1,0,0,0,1828,1826,1,0,0,0,1829,1831,3,140,70,0,
        1830,1829,1,0,0,0,1830,1831,1,0,0,0,1831,1832,1,0,0,0,1832,1836,
        5,42,0,0,1833,1835,5,131,0,0,1834,1833,1,0,0,0,1835,1838,1,0,0,0,
        1836,1834,1,0,0,0,1836,1837,1,0,0,0,1837,1881,1,0,0,0,1838,1836,
        1,0,0,0,1839,1840,10,23,0,0,1840,1844,5,44,0,0,1841,1843,5,131,0,
        0,1842,1841,1,0,0,0,1843,1846,1,0,0,0,1844,1842,1,0,0,0,1844,1845,
        1,0,0,0,1845,1847,1,0,0,0,1846,1844,1,0,0,0,1847,1881,3,194,97,0,
        1848,1849,10,22,0,0,1849,1853,5,14,0,0,1850,1852,5,131,0,0,1851,
        1850,1,0,0,0,1852,1855,1,0,0,0,1853,1851,1,0,0,0,1853,1854,1,0,0,
        0,1854,1856,1,0,0,0,1855,1853,1,0,0,0,1856,1857,3,146,73,0,1857,
        1861,5,16,0,0,1858,1860,5,131,0,0,1859,1858,1,0,0,0,1860,1863,1,
        0,0,0,1861,1859,1,0,0,0,1861,1862,1,0,0,0,1862,1881,1,0,0,0,1863,
        1861,1,0,0,0,1864,1865,10,21,0,0,1865,1869,5,22,0,0,1866,1868,5,
        131,0,0,1867,1866,1,0,0,0,1868,1871,1,0,0,0,1869,1867,1,0,0,0,1869,
        1870,1,0,0,0,1870,1872,1,0,0,0,1871,1869,1,0,0,0,1872,1873,3,150,
        75,0,1873,1877,5,23,0,0,1874,1876,5,131,0,0,1875,1874,1,0,0,0,1876,
        1879,1,0,0,0,1877,1875,1,0,0,0,1877,1878,1,0,0,0,1878,1881,1,0,0,
        0,1879,1877,1,0,0,0,1880,1661,1,0,0,0,1880,1670,1,0,0,0,1880,1679,
        1,0,0,0,1880,1688,1,0,0,0,1880,1697,1,0,0,0,1880,1706,1,0,0,0,1880,
        1715,1,0,0,0,1880,1724,1,0,0,0,1880,1733,1,0,0,0,1880,1742,1,0,0,
        0,1880,1751,1,0,0,0,1880,1760,1,0,0,0,1880,1778,1,0,0,0,1880,1787,
        1,0,0,0,1880,1795,1,0,0,0,1880,1811,1,0,0,0,1880,1839,1,0,0,0,1880,
        1848,1,0,0,0,1880,1864,1,0,0,0,1881,1884,1,0,0,0,1882,1880,1,0,0,
        0,1882,1883,1,0,0,0,1883,141,1,0,0,0,1884,1882,1,0,0,0,1885,1889,
        5,102,0,0,1886,1888,5,131,0,0,1887,1886,1,0,0,0,1888,1891,1,0,0,
        0,1889,1887,1,0,0,0,1889,1890,1,0,0,0,1890,1913,1,0,0,0,1891,1889,
        1,0,0,0,1892,1913,3,192,96,0,1893,1913,3,196,98,0,1894,1913,3,200,
        100,0,1895,1913,3,194,97,0,1896,1900,5,122,0,0,1897,1899,5,131,0,
        0,1898,1897,1,0,0,0,1899,1902,1,0,0,0,1900,1898,1,0,0,0,1900,1901,
        1,0,0,0,1901,1913,1,0,0,0,1902,1900,1,0,0,0,1903,1907,5,117,0,0,
        1904,1906,5,131,0,0,1905,1904,1,0,0,0,1906,1909,1,0,0,0,1907,1905,
        1,0,0,0,1907,1908,1,0,0,0,1908,1913,1,0,0,0,1909,1907,1,0,0,0,1910,
        1913,3,190,95,0,1911,1913,3,76,38,0,1912,1885,1,0,0,0,1912,1892,
        1,0,0,0,1912,1893,1,0,0,0,1912,1894,1,0,0,0,1912,1895,1,0,0,0,1912,
        1896,1,0,0,0,1912,1903,1,0,0,0,1912,1910,1,0,0,0,1912,1911,1,0,0,
        0,1913,143,1,0,0,0,1914,1925,3,140,70,0,1915,1919,5,15,0,0,1916,
        1918,5,131,0,0,1917,1916,1,0,0,0,1918,1921,1,0,0,0,1919,1917,1,0,
        0,0,1919,1920,1,0,0,0,1920,1922,1,0,0,0,1921,1919,1,0,0,0,1922,1924,
        3,140,70,0,1923,1915,1,0,0,0,1924,1927,1,0,0,0,1925,1923,1,0,0,0,
        1925,1926,1,0,0,0,1926,145,1,0,0,0,1927,1925,1,0,0,0,1928,1939,3,
        148,74,0,1929,1933,5,15,0,0,1930,1932,5,131,0,0,1931,1930,1,0,0,
        0,1932,1935,1,0,0,0,1933,1931,1,0,0,0,1933,1934,1,0,0,0,1934,1936,
        1,0,0,0,1935,1933,1,0,0,0,1936,1938,3,148,74,0,1937,1929,1,0,0,0,
        1938,1941,1,0,0,0,1939,1937,1,0,0,0,1939,1940,1,0,0,0,1940,1949,
        1,0,0,0,1941,1939,1,0,0,0,1942,1946,5,15,0,0,1943,1945,5,131,0,0,
        1944,1943,1,0,0,0,1945,1948,1,0,0,0,1946,1944,1,0,0,0,1946,1947,
        1,0,0,0,1947,1950,1,0,0,0,1948,1946,1,0,0,0,1949,1942,1,0,0,0,1949,
        1950,1,0,0,0,1950,147,1,0,0,0,1951,1952,3,194,97,0,1952,1956,5,70,
        0,0,1953,1955,5,131,0,0,1954,1953,1,0,0,0,1955,1958,1,0,0,0,1956,
        1954,1,0,0,0,1956,1957,1,0,0,0,1957,1959,1,0,0,0,1958,1956,1,0,0,
        0,1959,1960,3,140,70,0,1960,149,1,0,0,0,1961,1965,5,14,0,0,1962,
        1964,5,131,0,0,1963,1962,1,0,0,0,1964,1967,1,0,0,0,1965,1963,1,0,
        0,0,1965,1966,1,0,0,0,1966,1969,1,0,0,0,1967,1965,1,0,0,0,1968,1970,
        3,146,73,0,1969,1968,1,0,0,0,1969,1970,1,0,0,0,1970,1971,1,0,0,0,
        1971,1975,5,16,0,0,1972,1974,5,131,0,0,1973,1972,1,0,0,0,1974,1977,
        1,0,0,0,1975,1973,1,0,0,0,1975,1976,1,0,0,0,1976,1982,1,0,0,0,1977,
        1975,1,0,0,0,1978,1980,3,144,72,0,1979,1978,1,0,0,0,1979,1980,1,
        0,0,0,1980,1982,1,0,0,0,1981,1961,1,0,0,0,1981,1979,1,0,0,0,1982,
        151,1,0,0,0,1983,1984,3,140,70,0,1984,1988,5,22,0,0,1985,1987,5,
        131,0,0,1986,1985,1,0,0,0,1987,1990,1,0,0,0,1988,1986,1,0,0,0,1988,
        1989,1,0,0,0,1989,1991,1,0,0,0,1990,1988,1,0,0,0,1991,1992,3,150,
        75,0,1992,1996,5,23,0,0,1993,1995,5,131,0,0,1994,1993,1,0,0,0,1995,
        1998,1,0,0,0,1996,1994,1,0,0,0,1996,1997,1,0,0,0,1997,153,1,0,0,
        0,1998,1996,1,0,0,0,1999,2003,5,14,0,0,2000,2002,5,131,0,0,2001,
        2000,1,0,0,0,2002,2005,1,0,0,0,2003,2001,1,0,0,0,2003,2004,1,0,0,
        0,2004,2009,1,0,0,0,2005,2003,1,0,0,0,2006,2008,3,156,78,0,2007,
        2006,1,0,0,0,2008,2011,1,0,0,0,2009,2007,1,0,0,0,2009,2010,1,0,0,
        0,2010,2012,1,0,0,0,2011,2009,1,0,0,0,2012,2016,5,16,0,0,2013,2015,
        5,131,0,0,2014,2013,1,0,0,0,2015,2018,1,0,0,0,2016,2014,1,0,0,0,
        2016,2017,1,0,0,0,2017,155,1,0,0,0,2018,2016,1,0,0,0,2019,2055,3,
        194,97,0,2020,2055,3,154,77,0,2021,2055,3,158,79,0,2022,2055,3,164,
        82,0,2023,2055,3,166,83,0,2024,2055,3,172,86,0,2025,2055,3,174,87,
        0,2026,2055,3,176,88,0,2027,2055,3,180,90,0,2028,2055,3,184,92,0,
        2029,2055,3,186,93,0,2030,2034,5,109,0,0,2031,2033,5,131,0,0,2032,
        2031,1,0,0,0,2033,2036,1,0,0,0,2034,2032,1,0,0,0,2034,2035,1,0,0,
        0,2035,2055,1,0,0,0,2036,2034,1,0,0,0,2037,2041,5,112,0,0,2038,2040,
        5,131,0,0,2039,2038,1,0,0,0,2040,2043,1,0,0,0,2041,2039,1,0,0,0,
        2041,2042,1,0,0,0,2042,2055,1,0,0,0,2043,2041,1,0,0,0,2044,2048,
        5,113,0,0,2045,2047,5,131,0,0,2046,2045,1,0,0,0,2047,2050,1,0,0,
        0,2048,2046,1,0,0,0,2048,2049,1,0,0,0,2049,2055,1,0,0,0,2050,2048,
        1,0,0,0,2051,2055,3,192,96,0,2052,2055,3,200,100,0,2053,2055,3,196,
        98,0,2054,2019,1,0,0,0,2054,2020,1,0,0,0,2054,2021,1,0,0,0,2054,
        2022,1,0,0,0,2054,2023,1,0,0,0,2054,2024,1,0,0,0,2054,2025,1,0,0,
        0,2054,2026,1,0,0,0,2054,2027,1,0,0,0,2054,2028,1,0,0,0,2054,2029,
        1,0,0,0,2054,2030,1,0,0,0,2054,2037,1,0,0,0,2054,2044,1,0,0,0,2054,
        2051,1,0,0,0,2054,2052,1,0,0,0,2054,2053,1,0,0,0,2055,157,1,0,0,
        0,2056,2060,3,162,81,0,2057,2060,3,188,94,0,2058,2060,3,160,80,0,
        2059,2056,1,0,0,0,2059,2057,1,0,0,0,2059,2058,1,0,0,0,2060,159,1,
        0,0,0,2061,2062,3,194,97,0,2062,2066,5,44,0,0,2063,2065,5,131,0,
        0,2064,2063,1,0,0,0,2065,2068,1,0,0,0,2066,2064,1,0,0,0,2066,2067,
        1,0,0,0,2067,2069,1,0,0,0,2068,2066,1,0,0,0,2069,2070,3,194,97,0,
        2070,161,1,0,0,0,2071,2075,5,59,0,0,2072,2074,5,131,0,0,2073,2072,
        1,0,0,0,2074,2077,1,0,0,0,2075,2073,1,0,0,0,2075,2076,1,0,0,0,2076,
        2094,1,0,0,0,2077,2075,1,0,0,0,2078,2082,5,43,0,0,2079,2081,5,131,
        0,0,2080,2079,1,0,0,0,2081,2084,1,0,0,0,2082,2080,1,0,0,0,2082,2083,
        1,0,0,0,2083,2094,1,0,0,0,2084,2082,1,0,0,0,2085,2089,5,66,0,0,2086,
        2088,5,131,0,0,2087,2086,1,0,0,0,2088,2091,1,0,0,0,2089,2087,1,0,
        0,0,2089,2090,1,0,0,0,2090,2094,1,0,0,0,2091,2089,1,0,0,0,2092,2094,
        3,194,97,0,2093,2071,1,0,0,0,2093,2078,1,0,0,0,2093,2085,1,0,0,0,
        2093,2092,1,0,0,0,2094,2125,1,0,0,0,2095,2099,5,22,0,0,2096,2098,
        5,131,0,0,2097,2096,1,0,0,0,2098,2101,1,0,0,0,2099,2097,1,0,0,0,
        2099,2100,1,0,0,0,2100,2103,1,0,0,0,2101,2099,1,0,0,0,2102,2104,
        3,158,79,0,2103,2102,1,0,0,0,2103,2104,1,0,0,0,2104,2115,1,0,0,0,
        2105,2109,5,15,0,0,2106,2108,5,131,0,0,2107,2106,1,0,0,0,2108,2111,
        1,0,0,0,2109,2107,1,0,0,0,2109,2110,1,0,0,0,2110,2112,1,0,0,0,2111,
        2109,1,0,0,0,2112,2114,3,158,79,0,2113,2105,1,0,0,0,2114,2117,1,
        0,0,0,2115,2113,1,0,0,0,2115,2116,1,0,0,0,2116,2118,1,0,0,0,2117,
        2115,1,0,0,0,2118,2122,5,23,0,0,2119,2121,5,131,0,0,2120,2119,1,
        0,0,0,2121,2124,1,0,0,0,2122,2120,1,0,0,0,2122,2123,1,0,0,0,2123,
        2126,1,0,0,0,2124,2122,1,0,0,0,2125,2095,1,0,0,0,2125,2126,1,0,0,
        0,2126,163,1,0,0,0,2127,2131,5,88,0,0,2128,2130,5,131,0,0,2129,2128,
        1,0,0,0,2130,2133,1,0,0,0,2131,2129,1,0,0,0,2131,2132,1,0,0,0,2132,
        2134,1,0,0,0,2133,2131,1,0,0,0,2134,2143,3,168,84,0,2135,2139,5,
        89,0,0,2136,2138,5,131,0,0,2137,2136,1,0,0,0,2138,2141,1,0,0,0,2139,
        2137,1,0,0,0,2139,2140,1,0,0,0,2140,2142,1,0,0,0,2141,2139,1,0,0,
        0,2142,2144,3,158,79,0,2143,2135,1,0,0,0,2143,2144,1,0,0,0,2144,
        165,1,0,0,0,2145,2146,3,168,84,0,2146,2150,5,89,0,0,2147,2149,5,
        131,0,0,2148,2147,1,0,0,0,2149,2152,1,0,0,0,2150,2148,1,0,0,0,2150,
        2151,1,0,0,0,2151,2153,1,0,0,0,2152,2150,1,0,0,0,2153,2154,3,158,
        79,0,2154,167,1,0,0,0,2155,2174,3,194,97,0,2156,2174,3,160,80,0,
        2157,2174,3,170,85,0,2158,2162,5,22,0,0,2159,2161,5,131,0,0,2160,
        2159,1,0,0,0,2161,2164,1,0,0,0,2162,2160,1,0,0,0,2162,2163,1,0,0,
        0,2163,2165,1,0,0,0,2164,2162,1,0,0,0,2165,2166,3,170,85,0,2166,
        2170,5,23,0,0,2167,2169,5,131,0,0,2168,2167,1,0,0,0,2169,2172,1,
        0,0,0,2170,2168,1,0,0,0,2170,2171,1,0,0,0,2171,2174,1,0,0,0,2172,
        2170,1,0,0,0,2173,2155,1,0,0,0,2173,2156,1,0,0,0,2173,2157,1,0,0,
        0,2173,2158,1,0,0,0,2174,169,1,0,0,0,2175,2186,3,194,97,0,2176,2180,
        5,15,0,0,2177,2179,5,131,0,0,2178,2177,1,0,0,0,2179,2182,1,0,0,0,
        2180,2178,1,0,0,0,2180,2181,1,0,0,0,2181,2183,1,0,0,0,2182,2180,
        1,0,0,0,2183,2185,3,194,97,0,2184,2176,1,0,0,0,2185,2188,1,0,0,0,
        2186,2184,1,0,0,0,2186,2187,1,0,0,0,2187,171,1,0,0,0,2188,2186,1,
        0,0,0,2189,2190,3,158,79,0,2190,2194,5,90,0,0,2191,2193,5,131,0,
        0,2192,2191,1,0,0,0,2193,2196,1,0,0,0,2194,2192,1,0,0,0,2194,2195,
        1,0,0,0,2195,2197,1,0,0,0,2196,2194,1,0,0,0,2197,2198,3,194,97,0,
        2198,173,1,0,0,0,2199,2200,3,194,97,0,2200,2204,5,70,0,0,2201,2203,
        5,131,0,0,2202,2201,1,0,0,0,2203,2206,1,0,0,0,2204,2202,1,0,0,0,
        2204,2205,1,0,0,0,2205,175,1,0,0,0,2206,2204,1,0,0,0,2207,2211,5,
        91,0,0,2208,2210,5,131,0,0,2209,2208,1,0,0,0,2210,2213,1,0,0,0,2211,
        2209,1,0,0,0,2211,2212,1,0,0,0,2212,2214,1,0,0,0,2213,2211,1,0,0,
        0,2214,2218,3,158,79,0,2215,2217,3,178,89,0,2216,2215,1,0,0,0,2217,
        2220,1,0,0,0,2218,2216,1,0,0,0,2218,2219,1,0,0,0,2219,177,1,0,0,
        0,2220,2218,1,0,0,0,2221,2225,5,92,0,0,2222,2224,5,131,0,0,2223,
        2222,1,0,0,0,2224,2227,1,0,0,0,2225,2223,1,0,0,0,2225,2226,1,0,0,
        0,2226,2228,1,0,0,0,2227,2225,1,0,0,0,2228,2229,3,188,94,0,2229,
        2230,3,154,77,0,2230,2240,1,0,0,0,2231,2235,5,93,0,0,2232,2234,5,
        131,0,0,2233,2232,1,0,0,0,2234,2237,1,0,0,0,2235,2233,1,0,0,0,2235,
        2236,1,0,0,0,2236,2238,1,0,0,0,2237,2235,1,0,0,0,2238,2240,3,154,
        77,0,2239,2221,1,0,0,0,2239,2231,1,0,0,0,2240,179,1,0,0,0,2241,2245,
        5,37,0,0,2242,2244,5,131,0,0,2243,2242,1,0,0,0,2244,2247,1,0,0,0,
        2245,2243,1,0,0,0,2245,2246,1,0,0,0,2246,2248,1,0,0,0,2247,2245,
        1,0,0,0,2248,2249,3,194,97,0,2249,2253,5,22,0,0,2250,2252,5,131,
        0,0,2251,2250,1,0,0,0,2252,2255,1,0,0,0,2253,2251,1,0,0,0,2253,2254,
        1,0,0,0,2254,2257,1,0,0,0,2255,2253,1,0,0,0,2256,2258,3,170,85,0,
        2257,2256,1,0,0,0,2257,2258,1,0,0,0,2258,2259,1,0,0,0,2259,2263,
        5,23,0,0,2260,2262,5,131,0,0,2261,2260,1,0,0,0,2262,2265,1,0,0,0,
        2263,2261,1,0,0,0,2263,2264,1,0,0,0,2264,2267,1,0,0,0,2265,2263,
        1,0,0,0,2266,2268,3,182,91,0,2267,2266,1,0,0,0,2267,2268,1,0,0,0,
        2268,2269,1,0,0,0,2269,2270,3,154,77,0,2270,181,1,0,0,0,2271,2275,
        5,94,0,0,2272,2274,5,131,0,0,2273,2272,1,0,0,0,2274,2277,1,0,0,0,
        2275,2273,1,0,0,0,2275,2276,1,0,0,0,2276,2278,1,0,0,0,2277,2275,
        1,0,0,0,2278,2279,3,170,85,0,2279,183,1,0,0,0,2280,2284,5,26,0,0,
        2281,2283,5,131,0,0,2282,2281,1,0,0,0,2283,2286,1,0,0,0,2284,2282,
        1,0,0,0,2284,2285,1,0,0,0,2285,2289,1,0,0,0,2286,2284,1,0,0,0,2287,
        2290,3,154,77,0,2288,2290,3,158,79,0,2289,2287,1,0,0,0,2289,2288,
        1,0,0,0,2290,2291,1,0,0,0,2291,2294,3,158,79,0,2292,2295,3,154,77,
        0,2293,2295,3,158,79,0,2294,2292,1,0,0,0,2294,2293,1,0,0,0,2295,
        2296,1,0,0,0,2296,2297,3,154,77,0,2297,185,1,0,0,0,2298,2302,5,50,
        0,0,2299,2301,5,131,0,0,2300,2299,1,0,0,0,2301,2304,1,0,0,0,2302,
        2300,1,0,0,0,2302,2303,1,0,0,0,2303,2305,1,0,0,0,2304,2302,1,0,0,
        0,2305,2306,3,158,79,0,2306,2307,3,154,77,0,2307,187,1,0,0,0,2308,
        2326,3,200,100,0,2309,2313,5,103,0,0,2310,2312,5,131,0,0,2311,2310,
        1,0,0,0,2312,2315,1,0,0,0,2313,2311,1,0,0,0,2313,2314,1,0,0,0,2314,
        2326,1,0,0,0,2315,2313,1,0,0,0,2316,2320,5,104,0,0,2317,2319,5,131,
        0,0,2318,2317,1,0,0,0,2319,2322,1,0,0,0,2320,2318,1,0,0,0,2320,2321,
        1,0,0,0,2321,2326,1,0,0,0,2322,2320,1,0,0,0,2323,2326,3,196,98,0,
        2324,2326,5,102,0,0,2325,2308,1,0,0,0,2325,2309,1,0,0,0,2325,2316,
        1,0,0,0,2325,2323,1,0,0,0,2325,2324,1,0,0,0,2326,189,1,0,0,0,2327,
        2331,5,22,0,0,2328,2330,5,131,0,0,2329,2328,1,0,0,0,2330,2333,1,
        0,0,0,2331,2329,1,0,0,0,2331,2332,1,0,0,0,2332,2335,1,0,0,0,2333,
        2331,1,0,0,0,2334,2336,3,140,70,0,2335,2334,1,0,0,0,2335,2336,1,
        0,0,0,2336,2349,1,0,0,0,2337,2341,5,15,0,0,2338,2340,5,131,0,0,2339,
        2338,1,0,0,0,2340,2343,1,0,0,0,2341,2339,1,0,0,0,2341,2342,1,0,0,
        0,2342,2345,1,0,0,0,2343,2341,1,0,0,0,2344,2346,3,140,70,0,2345,
        2344,1,0,0,0,2345,2346,1,0,0,0,2346,2348,1,0,0,0,2347,2337,1,0,0,
        0,2348,2351,1,0,0,0,2349,2347,1,0,0,0,2349,2350,1,0,0,0,2350,2352,
        1,0,0,0,2351,2349,1,0,0,0,2352,2356,5,23,0,0,2353,2355,5,131,0,0,
        2354,2353,1,0,0,0,2355,2358,1,0,0,0,2356,2354,1,0,0,0,2356,2357,
        1,0,0,0,2357,2390,1,0,0,0,2358,2356,1,0,0,0,2359,2363,5,41,0,0,2360,
        2362,5,131,0,0,2361,2360,1,0,0,0,2362,2365,1,0,0,0,2363,2361,1,0,
        0,0,2363,2364,1,0,0,0,2364,2380,1,0,0,0,2365,2363,1,0,0,0,2366,2377,
        3,140,70,0,2367,2371,5,15,0,0,2368,2370,5,131,0,0,2369,2368,1,0,
        0,0,2370,2373,1,0,0,0,2371,2369,1,0,0,0,2371,2372,1,0,0,0,2372,2374,
        1,0,0,0,2373,2371,1,0,0,0,2374,2376,3,140,70,0,2375,2367,1,0,0,0,
        2376,2379,1,0,0,0,2377,2375,1,0,0,0,2377,2378,1,0,0,0,2378,2381,
        1,0,0,0,2379,2377,1,0,0,0,2380,2366,1,0,0,0,2380,2381,1,0,0,0,2381,
        2382,1,0,0,0,2382,2386,5,42,0,0,2383,2385,5,131,0,0,2384,2383,1,
        0,0,0,2385,2388,1,0,0,0,2386,2384,1,0,0,0,2386,2387,1,0,0,0,2387,
        2390,1,0,0,0,2388,2386,1,0,0,0,2389,2327,1,0,0,0,2389,2359,1,0,0,
        0,2390,191,1,0,0,0,2391,2395,5,103,0,0,2392,2394,5,131,0,0,2393,
        2392,1,0,0,0,2394,2397,1,0,0,0,2395,2393,1,0,0,0,2395,2396,1,0,0,
        0,2396,2406,1,0,0,0,2397,2395,1,0,0,0,2398,2402,5,104,0,0,2399,2401,
        5,131,0,0,2400,2399,1,0,0,0,2401,2404,1,0,0,0,2402,2400,1,0,0,0,
        2402,2403,1,0,0,0,2403,2406,1,0,0,0,2404,2402,1,0,0,0,2405,2391,
        1,0,0,0,2405,2398,1,0,0,0,2406,2414,1,0,0,0,2407,2411,5,105,0,0,
        2408,2410,5,131,0,0,2409,2408,1,0,0,0,2410,2413,1,0,0,0,2411,2409,
        1,0,0,0,2411,2412,1,0,0,0,2412,2415,1,0,0,0,2413,2411,1,0,0,0,2414,
        2407,1,0,0,0,2414,2415,1,0,0,0,2415,193,1,0,0,0,2416,2420,7,13,0,
        0,2417,2419,5,131,0,0,2418,2417,1,0,0,0,2419,2422,1,0,0,0,2420,2418,
        1,0,0,0,2420,2421,1,0,0,0,2421,195,1,0,0,0,2422,2420,1,0,0,0,2423,
        2427,5,106,0,0,2424,2426,5,131,0,0,2425,2424,1,0,0,0,2426,2429,1,
        0,0,0,2427,2425,1,0,0,0,2427,2428,1,0,0,0,2428,2431,1,0,0,0,2429,
        2427,1,0,0,0,2430,2423,1,0,0,0,2431,2432,1,0,0,0,2432,2430,1,0,0,
        0,2432,2433,1,0,0,0,2433,197,1,0,0,0,2434,2438,5,96,0,0,2435,2437,
        5,131,0,0,2436,2435,1,0,0,0,2437,2440,1,0,0,0,2438,2436,1,0,0,0,
        2438,2439,1,0,0,0,2439,2469,1,0,0,0,2440,2438,1,0,0,0,2441,2445,
        5,22,0,0,2442,2444,5,131,0,0,2443,2442,1,0,0,0,2444,2447,1,0,0,0,
        2445,2443,1,0,0,0,2445,2446,1,0,0,0,2446,2448,1,0,0,0,2447,2445,
        1,0,0,0,2448,2459,3,78,39,0,2449,2453,5,15,0,0,2450,2452,5,131,0,
        0,2451,2450,1,0,0,0,2452,2455,1,0,0,0,2453,2451,1,0,0,0,2453,2454,
        1,0,0,0,2454,2456,1,0,0,0,2455,2453,1,0,0,0,2456,2458,3,78,39,0,
        2457,2449,1,0,0,0,2458,2461,1,0,0,0,2459,2457,1,0,0,0,2459,2460,
        1,0,0,0,2460,2462,1,0,0,0,2461,2459,1,0,0,0,2462,2466,5,23,0,0,2463,
        2465,5,131,0,0,2464,2463,1,0,0,0,2465,2468,1,0,0,0,2466,2464,1,0,
        0,0,2466,2467,1,0,0,0,2467,2470,1,0,0,0,2468,2466,1,0,0,0,2469,2441,
        1,0,0,0,2469,2470,1,0,0,0,2470,199,1,0,0,0,2471,2475,5,129,0,0,2472,
        2474,5,131,0,0,2473,2472,1,0,0,0,2474,2477,1,0,0,0,2475,2473,1,0,
        0,0,2475,2476,1,0,0,0,2476,2479,1,0,0,0,2477,2475,1,0,0,0,2478,2471,
        1,0,0,0,2479,2480,1,0,0,0,2480,2478,1,0,0,0,2480,2481,1,0,0,0,2481,
        201,1,0,0,0,2482,2484,5,131,0,0,2483,2482,1,0,0,0,2484,2487,1,0,
        0,0,2485,2483,1,0,0,0,2485,2486,1,0,0,0,2486,2488,1,0,0,0,2487,2485,
        1,0,0,0,2488,2492,5,56,0,0,2489,2491,5,131,0,0,2490,2489,1,0,0,0,
        2491,2494,1,0,0,0,2492,2490,1,0,0,0,2492,2493,1,0,0,0,2493,2501,
        1,0,0,0,2494,2492,1,0,0,0,2495,2497,5,131,0,0,2496,2495,1,0,0,0,
        2497,2498,1,0,0,0,2498,2496,1,0,0,0,2498,2499,1,0,0,0,2499,2501,
        1,0,0,0,2500,2485,1,0,0,0,2500,2496,1,0,0,0,2501,203,1,0,0,0,357,
        207,224,226,235,248,253,260,263,268,275,279,285,289,295,298,305,
        309,315,323,327,335,342,346,352,356,362,372,379,387,393,400,407,
        413,421,424,430,438,446,452,455,461,467,474,482,486,492,495,506,
        513,520,527,534,541,545,547,555,559,568,576,586,597,605,615,623,
        630,634,640,643,652,660,666,673,676,683,687,693,700,708,718,721,
        727,734,739,745,749,751,756,763,767,773,776,782,786,792,796,802,
        809,816,819,825,834,841,848,855,862,868,870,877,886,889,899,907,
        911,917,923,930,937,945,951,954,960,965,968,974,982,988,991,997,
        1005,1008,1011,1017,1025,1031,1034,1040,1045,1049,1062,1069,1072,
        1079,1083,1089,1094,1102,1108,1113,1119,1126,1131,1137,1142,1148,
        1159,1167,1174,1178,1180,1187,1191,1197,1204,1211,1217,1224,1242,
        1251,1258,1266,1274,1278,1284,1289,1295,1301,1305,1308,1316,1323,
        1331,1338,1344,1353,1360,1368,1371,1378,1381,1384,1390,1399,1406,
        1409,1415,1423,1426,1436,1444,1451,1468,1472,1483,1493,1503,1512,
        1520,1523,1529,1533,1538,1544,1548,1552,1559,1563,1569,1574,1578,
        1584,1591,1599,1607,1615,1622,1630,1638,1646,1654,1659,1666,1675,
        1684,1693,1702,1711,1720,1729,1738,1747,1756,1765,1773,1783,1792,
        1800,1808,1816,1820,1826,1830,1836,1844,1853,1861,1869,1877,1880,
        1882,1889,1900,1907,1912,1919,1925,1933,1939,1946,1949,1956,1965,
        1969,1975,1979,1981,1988,1996,2003,2009,2016,2034,2041,2048,2054,
        2059,2066,2075,2082,2089,2093,2099,2103,2109,2115,2122,2125,2131,
        2139,2143,2150,2162,2170,2173,2180,2186,2194,2204,2211,2218,2225,
        2235,2239,2245,2253,2257,2263,2267,2275,2284,2289,2294,2302,2313,
        2320,2325,2331,2335,2341,2345,2349,2356,2363,2371,2377,2380,2386,
        2389,2395,2402,2405,2411,2414,2420,2427,2432,2438,2445,2453,2459,
        2466,2469,2475,2480,2485,2492,2498,2500
    ]

class SolidityParser ( Parser ):

    grammarFileName = "Solidity.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'pragma'", "'*'", "'||'", "'^'", "'~'", 
                     "'>='", "'>'", "'<'", "'<='", "'='", "'as'", "'import'", 
                     "'from'", "'{'", "','", "'}'", "'abstract'", "'contract'", 
                     "'interface'", "'library'", "'is'", "'('", "')'", "'error'", 
                     "'using'", "'for'", "'|'", "'&'", "'+'", "'-'", "'/'", 
                     "'%'", "'=='", "'!='", "'struct'", "'modifier'", "'function'", 
                     "'returns'", "'event'", "'enum'", "'['", "']'", "'address'", 
                     "'.'", "'mapping'", "'=>'", "'memory'", "'storage'", 
                     "'calldata'", "'if'", "'else'", "'try'", "'catch'", 
                     "'while'", "'unchecked'", "';'", "'assembly'", "'do'", 
                     "'return'", "'throw'", "'emit'", "'revert'", "'var'", 
                     "'bool'", "'string'", "'byte'", "'++'", "'--'", "'new'", 
                     "':'", "'delete'", "'!'", "'**'", "'<<'", "'>>'", "'&&'", 
                     "'?'", "'|='", "'^='", "'&='", "'<<='", "'>>='", "'+='", 
                     "'-='", "'*='", "'/='", "'%='", "'let'", "':='", "'=:'", 
                     "'switch'", "'case'", "'default'", "'->'", "'callback'", 
                     "'override'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'anonymous'", "'break'", "'constant'", "'immutable'", 
                     "'continue'", "'leave'", "'external'", "'indexed'", 
                     "'internal'", "'payable'", "'private'", "'public'", 
                     "'virtual'", "'pure'", "'type'", "'view'", "'global'", 
                     "'constructor'", "'fallback'", "'receive'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "Int", "Uint", "Byte", "Fixed", "Ufixed", 
                      "BooleanLiteral", "DecimalNumber", "HexNumber", "NumberUnit", 
                      "HexLiteralFragment", "ReservedKeyword", "AnonymousKeyword", 
                      "BreakKeyword", "ConstantKeyword", "ImmutableKeyword", 
                      "ContinueKeyword", "LeaveKeyword", "ExternalKeyword", 
                      "IndexedKeyword", "InternalKeyword", "PayableKeyword", 
                      "PrivateKeyword", "PublicKeyword", "VirtualKeyword", 
                      "PureKeyword", "TypeKeyword", "ViewKeyword", "GlobalKeyword", 
                      "ConstructorKeyword", "FallbackKeyword", "ReceiveKeyword", 
                      "Identifier", "StringLiteralFragment", "VersionLiteral", 
                      "NL", "WS", "COMMENT", "LINE_COMMENT" ]

    RULE_sourceUnit = 0
    RULE_pragmaDirective = 1
    RULE_pragmaName = 2
    RULE_pragmaValue = 3
    RULE_version = 4
    RULE_versionOperator = 5
    RULE_versionConstraint = 6
    RULE_importDeclaration = 7
    RULE_importDirective = 8
    RULE_importPath = 9
    RULE_contractDefinition = 10
    RULE_inheritanceSpecifier = 11
    RULE_contractPart = 12
    RULE_stateVariableDeclaration = 13
    RULE_fileLevelConstant = 14
    RULE_customErrorDefinition = 15
    RULE_typeDefinition = 16
    RULE_usingForDeclaration = 17
    RULE_usingForObject = 18
    RULE_usingForObjectDirective = 19
    RULE_userDefinableOperators = 20
    RULE_structDefinition = 21
    RULE_modifierDefinition = 22
    RULE_modifierInvocation = 23
    RULE_functionDefinition = 24
    RULE_functionDescriptor = 25
    RULE_returnParameters = 26
    RULE_modifierList = 27
    RULE_eventDefinition = 28
    RULE_enumValue = 29
    RULE_enumDefinition = 30
    RULE_parameterList = 31
    RULE_parameter = 32
    RULE_eventParameterList = 33
    RULE_eventParameter = 34
    RULE_functionTypeParameterList = 35
    RULE_functionTypeParameter = 36
    RULE_variableDeclaration = 37
    RULE_typeName = 38
    RULE_userDefinedTypeName = 39
    RULE_mappingKey = 40
    RULE_mapping = 41
    RULE_mappingKeyName = 42
    RULE_mappingValueName = 43
    RULE_functionTypeName = 44
    RULE_storageLocation = 45
    RULE_stateMutability = 46
    RULE_block = 47
    RULE_statement = 48
    RULE_expressionStatement = 49
    RULE_ifStatement = 50
    RULE_tryStatement = 51
    RULE_catchClause = 52
    RULE_whileStatement = 53
    RULE_simpleStatement = 54
    RULE_uncheckedStatement = 55
    RULE_forStatement = 56
    RULE_inlineAssemblyStatement = 57
    RULE_inlineAssemblyStatementFlag = 58
    RULE_doWhileStatement = 59
    RULE_continueStatement = 60
    RULE_breakStatement = 61
    RULE_returnStatement = 62
    RULE_throwStatement = 63
    RULE_emitStatement = 64
    RULE_revertStatement = 65
    RULE_variableDeclarationStatement = 66
    RULE_variableDeclarationList = 67
    RULE_identifierList = 68
    RULE_elementaryTypeName = 69
    RULE_expression = 70
    RULE_primaryExpression = 71
    RULE_expressionList = 72
    RULE_nameValueList = 73
    RULE_nameValue = 74
    RULE_functionCallArguments = 75
    RULE_functionCall = 76
    RULE_assemblyBlock = 77
    RULE_assemblyItem = 78
    RULE_assemblyExpression = 79
    RULE_assemblyMember = 80
    RULE_assemblyCall = 81
    RULE_assemblyLocalDefinition = 82
    RULE_assemblyAssignment = 83
    RULE_assemblyIdentifierOrList = 84
    RULE_assemblyIdentifierList = 85
    RULE_assemblyStackAssignment = 86
    RULE_labelDefinition = 87
    RULE_assemblySwitch = 88
    RULE_assemblyCase = 89
    RULE_assemblyFunctionDefinition = 90
    RULE_assemblyFunctionReturns = 91
    RULE_assemblyFor = 92
    RULE_assemblyIf = 93
    RULE_assemblyLiteral = 94
    RULE_tupleExpression = 95
    RULE_numberLiteral = 96
    RULE_identifier = 97
    RULE_hexLiteral = 98
    RULE_overrideSpecifier = 99
    RULE_stringLiteral = 100
    RULE_eos = 101

    ruleNames =  [ "sourceUnit", "pragmaDirective", "pragmaName", "pragmaValue", 
                   "version", "versionOperator", "versionConstraint", "importDeclaration", 
                   "importDirective", "importPath", "contractDefinition", 
                   "inheritanceSpecifier", "contractPart", "stateVariableDeclaration", 
                   "fileLevelConstant", "customErrorDefinition", "typeDefinition", 
                   "usingForDeclaration", "usingForObject", "usingForObjectDirective", 
                   "userDefinableOperators", "structDefinition", "modifierDefinition", 
                   "modifierInvocation", "functionDefinition", "functionDescriptor", 
                   "returnParameters", "modifierList", "eventDefinition", 
                   "enumValue", "enumDefinition", "parameterList", "parameter", 
                   "eventParameterList", "eventParameter", "functionTypeParameterList", 
                   "functionTypeParameter", "variableDeclaration", "typeName", 
                   "userDefinedTypeName", "mappingKey", "mapping", "mappingKeyName", 
                   "mappingValueName", "functionTypeName", "storageLocation", 
                   "stateMutability", "block", "statement", "expressionStatement", 
                   "ifStatement", "tryStatement", "catchClause", "whileStatement", 
                   "simpleStatement", "uncheckedStatement", "forStatement", 
                   "inlineAssemblyStatement", "inlineAssemblyStatementFlag", 
                   "doWhileStatement", "continueStatement", "breakStatement", 
                   "returnStatement", "throwStatement", "emitStatement", 
                   "revertStatement", "variableDeclarationStatement", "variableDeclarationList", 
                   "identifierList", "elementaryTypeName", "expression", 
                   "primaryExpression", "expressionList", "nameValueList", 
                   "nameValue", "functionCallArguments", "functionCall", 
                   "assemblyBlock", "assemblyItem", "assemblyExpression", 
                   "assemblyMember", "assemblyCall", "assemblyLocalDefinition", 
                   "assemblyAssignment", "assemblyIdentifierOrList", "assemblyIdentifierList", 
                   "assemblyStackAssignment", "labelDefinition", "assemblySwitch", 
                   "assemblyCase", "assemblyFunctionDefinition", "assemblyFunctionReturns", 
                   "assemblyFor", "assemblyIf", "assemblyLiteral", "tupleExpression", 
                   "numberLiteral", "identifier", "hexLiteral", "overrideSpecifier", 
                   "stringLiteral", "eos" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    T__19=20
    T__20=21
    T__21=22
    T__22=23
    T__23=24
    T__24=25
    T__25=26
    T__26=27
    T__27=28
    T__28=29
    T__29=30
    T__30=31
    T__31=32
    T__32=33
    T__33=34
    T__34=35
    T__35=36
    T__36=37
    T__37=38
    T__38=39
    T__39=40
    T__40=41
    T__41=42
    T__42=43
    T__43=44
    T__44=45
    T__45=46
    T__46=47
    T__47=48
    T__48=49
    T__49=50
    T__50=51
    T__51=52
    T__52=53
    T__53=54
    T__54=55
    T__55=56
    T__56=57
    T__57=58
    T__58=59
    T__59=60
    T__60=61
    T__61=62
    T__62=63
    T__63=64
    T__64=65
    T__65=66
    T__66=67
    T__67=68
    T__68=69
    T__69=70
    T__70=71
    T__71=72
    T__72=73
    T__73=74
    T__74=75
    T__75=76
    T__76=77
    T__77=78
    T__78=79
    T__79=80
    T__80=81
    T__81=82
    T__82=83
    T__83=84
    T__84=85
    T__85=86
    T__86=87
    T__87=88
    T__88=89
    T__89=90
    T__90=91
    T__91=92
    T__92=93
    T__93=94
    T__94=95
    T__95=96
    Int=97
    Uint=98
    Byte=99
    Fixed=100
    Ufixed=101
    BooleanLiteral=102
    DecimalNumber=103
    HexNumber=104
    NumberUnit=105
    HexLiteralFragment=106
    ReservedKeyword=107
    AnonymousKeyword=108
    BreakKeyword=109
    ConstantKeyword=110
    ImmutableKeyword=111
    ContinueKeyword=112
    LeaveKeyword=113
    ExternalKeyword=114
    IndexedKeyword=115
    InternalKeyword=116
    PayableKeyword=117
    PrivateKeyword=118
    PublicKeyword=119
    VirtualKeyword=120
    PureKeyword=121
    TypeKeyword=122
    ViewKeyword=123
    GlobalKeyword=124
    ConstructorKeyword=125
    FallbackKeyword=126
    ReceiveKeyword=127
    Identifier=128
    StringLiteralFragment=129
    VersionLiteral=130
    NL=131
    WS=132
    COMMENT=133
    LINE_COMMENT=134

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.13.0")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None




    class SourceUnitContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EOF(self):
            return self.getToken(SolidityParser.EOF, 0)

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def pragmaDirective(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.PragmaDirectiveContext)
            else:
                return self.getTypedRuleContext(SolidityParser.PragmaDirectiveContext,i)


        def importDirective(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ImportDirectiveContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ImportDirectiveContext,i)


        def contractDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ContractDefinitionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ContractDefinitionContext,i)


        def contractPart(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ContractPartContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ContractPartContext,i)


        def enumDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.EnumDefinitionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.EnumDefinitionContext,i)


        def structDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.StructDefinitionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.StructDefinitionContext,i)


        def functionDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.FunctionDefinitionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.FunctionDefinitionContext,i)


        def fileLevelConstant(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.FileLevelConstantContext)
            else:
                return self.getTypedRuleContext(SolidityParser.FileLevelConstantContext,i)


        def customErrorDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.CustomErrorDefinitionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.CustomErrorDefinitionContext,i)


        def typeDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.TypeDefinitionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.TypeDefinitionContext,i)


        def usingForDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.UsingForDeclarationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.UsingForDeclarationContext,i)


        def expressionStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ExpressionStatementContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ExpressionStatementContext,i)


        def block(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.BlockContext)
            else:
                return self.getTypedRuleContext(SolidityParser.BlockContext,i)


        def statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.StatementContext)
            else:
                return self.getTypedRuleContext(SolidityParser.StatementContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_sourceUnit

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSourceUnit" ):
                listener.enterSourceUnit(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSourceUnit" ):
                listener.exitSourceUnit(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSourceUnit" ):
                return visitor.visitSourceUnit(self)
            else:
                return visitor.visitChildren(self)




    def sourceUnit(self):

        localctx = SolidityParser.SourceUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_sourceUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 207
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 204
                self.match(SolidityParser.NL)
                self.state = 209
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 226
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & -83831472051556318) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -854797729270857281) != 0) or _la==128 or _la==129:
                self.state = 224
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
                if la_ == 1:
                    self.state = 210
                    self.pragmaDirective()
                    pass

                elif la_ == 2:
                    self.state = 211
                    self.importDirective()
                    pass

                elif la_ == 3:
                    self.state = 212
                    self.contractDefinition()
                    pass

                elif la_ == 4:
                    self.state = 213
                    self.contractPart()
                    pass

                elif la_ == 5:
                    self.state = 214
                    self.enumDefinition()
                    pass

                elif la_ == 6:
                    self.state = 215
                    self.structDefinition()
                    pass

                elif la_ == 7:
                    self.state = 216
                    self.functionDefinition()
                    pass

                elif la_ == 8:
                    self.state = 217
                    self.fileLevelConstant()
                    pass

                elif la_ == 9:
                    self.state = 218
                    self.customErrorDefinition()
                    pass

                elif la_ == 10:
                    self.state = 219
                    self.typeDefinition()
                    pass

                elif la_ == 11:
                    self.state = 220
                    self.usingForDeclaration()
                    pass

                elif la_ == 12:
                    self.state = 221
                    self.expressionStatement()
                    pass

                elif la_ == 13:
                    self.state = 222
                    self.block()
                    pass

                elif la_ == 14:
                    self.state = 223
                    self.statement()
                    pass


                self.state = 228
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 229
            self.match(SolidityParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PragmaDirectiveContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def pragmaName(self):
            return self.getTypedRuleContext(SolidityParser.PragmaNameContext,0)


        def pragmaValue(self):
            return self.getTypedRuleContext(SolidityParser.PragmaValueContext,0)


        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_pragmaDirective

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPragmaDirective" ):
                listener.enterPragmaDirective(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPragmaDirective" ):
                listener.exitPragmaDirective(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPragmaDirective" ):
                return visitor.visitPragmaDirective(self)
            else:
                return visitor.visitChildren(self)




    def pragmaDirective(self):

        localctx = SolidityParser.PragmaDirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_pragmaDirective)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 231
            self.match(SolidityParser.T__0)
            self.state = 235
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 232
                self.match(SolidityParser.NL)
                self.state = 237
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 238
            self.pragmaName()
            self.state = 239
            self.pragmaValue()
            self.state = 240
            self.eos()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PragmaNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_pragmaName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPragmaName" ):
                listener.enterPragmaName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPragmaName" ):
                listener.exitPragmaName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPragmaName" ):
                return visitor.visitPragmaName(self)
            else:
                return visitor.visitChildren(self)




    def pragmaName(self):

        localctx = SolidityParser.PragmaNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_pragmaName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 242
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PragmaValueContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def version(self):
            return self.getTypedRuleContext(SolidityParser.VersionContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_pragmaValue

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPragmaValue" ):
                listener.enterPragmaValue(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPragmaValue" ):
                listener.exitPragmaValue(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPragmaValue" ):
                return visitor.visitPragmaValue(self)
            else:
                return visitor.visitChildren(self)




    def pragmaValue(self):

        localctx = SolidityParser.PragmaValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_pragmaValue)
        try:
            self.state = 253
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 244
                self.match(SolidityParser.T__1)
                self.state = 248
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,4,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 245
                        self.match(SolidityParser.NL) 
                    self.state = 250
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,4,self._ctx)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 251
                self.version()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 252
                self.expression(0)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VersionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def versionConstraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.VersionConstraintContext)
            else:
                return self.getTypedRuleContext(SolidityParser.VersionConstraintContext,i)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_version

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVersion" ):
                listener.enterVersion(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVersion" ):
                listener.exitVersion(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVersion" ):
                return visitor.visitVersion(self)
            else:
                return visitor.visitChildren(self)




    def version(self):

        localctx = SolidityParser.VersionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_version)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 255
            self.versionConstraint()
            self.state = 268
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 2040) != 0) or _la==103 or _la==130:
                self.state = 263
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==3:
                    self.state = 256
                    self.match(SolidityParser.T__2)
                    self.state = 260
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 257
                        self.match(SolidityParser.NL)
                        self.state = 262
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 265
                self.versionConstraint()
                self.state = 270
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VersionOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_versionOperator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVersionOperator" ):
                listener.enterVersionOperator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVersionOperator" ):
                listener.exitVersionOperator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVersionOperator" ):
                return visitor.visitVersionOperator(self)
            else:
                return visitor.visitChildren(self)




    def versionOperator(self):

        localctx = SolidityParser.VersionOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_versionOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 271
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 2032) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 275
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 272
                self.match(SolidityParser.NL)
                self.state = 277
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VersionConstraintContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def VersionLiteral(self):
            return self.getToken(SolidityParser.VersionLiteral, 0)

        def versionOperator(self):
            return self.getTypedRuleContext(SolidityParser.VersionOperatorContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def DecimalNumber(self):
            return self.getToken(SolidityParser.DecimalNumber, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_versionConstraint

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVersionConstraint" ):
                listener.enterVersionConstraint(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVersionConstraint" ):
                listener.exitVersionConstraint(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVersionConstraint" ):
                return visitor.visitVersionConstraint(self)
            else:
                return visitor.visitChildren(self)




    def versionConstraint(self):

        localctx = SolidityParser.VersionConstraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_versionConstraint)
        self._la = 0 # Token type
        try:
            self.state = 298
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 279
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2032) != 0):
                    self.state = 278
                    self.versionOperator()


                self.state = 281
                self.match(SolidityParser.VersionLiteral)
                self.state = 285
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,11,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 282
                        self.match(SolidityParser.NL) 
                    self.state = 287
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,11,self._ctx)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 289
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2032) != 0):
                    self.state = 288
                    self.versionOperator()


                self.state = 291
                self.match(SolidityParser.DecimalNumber)
                self.state = 295
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,13,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 292
                        self.match(SolidityParser.NL) 
                    self.state = 297
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,13,self._ctx)

                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ImportDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_importDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterImportDeclaration" ):
                listener.enterImportDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitImportDeclaration" ):
                listener.exitImportDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitImportDeclaration" ):
                return visitor.visitImportDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def importDeclaration(self):

        localctx = SolidityParser.ImportDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_importDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 300
            self.identifier()
            self.state = 309
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==11:
                self.state = 301
                self.match(SolidityParser.T__10)
                self.state = 305
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 302
                    self.match(SolidityParser.NL)
                    self.state = 307
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 308
                self.identifier()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ImportDirectiveContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def importPath(self):
            return self.getTypedRuleContext(SolidityParser.ImportPathContext,0)


        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def importDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ImportDeclarationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ImportDeclarationContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_importDirective

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterImportDirective" ):
                listener.enterImportDirective(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitImportDirective" ):
                listener.exitImportDirective(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitImportDirective" ):
                return visitor.visitImportDirective(self)
            else:
                return visitor.visitChildren(self)




    def importDirective(self):

        localctx = SolidityParser.ImportDirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_importDirective)
        self._la = 0 # Token type
        try:
            self.state = 413
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 311
                self.match(SolidityParser.T__11)
                self.state = 315
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 312
                    self.match(SolidityParser.NL)
                    self.state = 317
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 318
                self.importPath()
                self.state = 327
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==11:
                    self.state = 319
                    self.match(SolidityParser.T__10)
                    self.state = 323
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 320
                        self.match(SolidityParser.NL)
                        self.state = 325
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 326
                    self.identifier()


                self.state = 329
                self.eos()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 331
                self.match(SolidityParser.T__11)
                self.state = 335
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 332
                    self.match(SolidityParser.NL)
                    self.state = 337
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 346
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [2]:
                    self.state = 338
                    self.match(SolidityParser.T__1)
                    self.state = 342
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 339
                        self.match(SolidityParser.NL)
                        self.state = 344
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass
                elif token in [13, 24, 43, 49, 62, 95, 113, 117, 124, 125, 127, 128]:
                    self.state = 345
                    self.identifier()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 356
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==11:
                    self.state = 348
                    self.match(SolidityParser.T__10)
                    self.state = 352
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 349
                        self.match(SolidityParser.NL)
                        self.state = 354
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 355
                    self.identifier()


                self.state = 358
                self.match(SolidityParser.T__12)
                self.state = 362
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 359
                    self.match(SolidityParser.NL)
                    self.state = 364
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 365
                self.importPath()
                self.state = 366
                self.eos()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 368
                self.match(SolidityParser.T__11)
                self.state = 372
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 369
                    self.match(SolidityParser.NL)
                    self.state = 374
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 375
                self.match(SolidityParser.T__13)
                self.state = 379
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 376
                    self.match(SolidityParser.NL)
                    self.state = 381
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 382
                self.importDeclaration()
                self.state = 393
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==15:
                    self.state = 383
                    self.match(SolidityParser.T__14)
                    self.state = 387
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 384
                        self.match(SolidityParser.NL)
                        self.state = 389
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 390
                    self.importDeclaration()
                    self.state = 395
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 396
                self.match(SolidityParser.T__15)
                self.state = 400
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 397
                    self.match(SolidityParser.NL)
                    self.state = 402
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 403
                self.match(SolidityParser.T__12)
                self.state = 407
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 404
                    self.match(SolidityParser.NL)
                    self.state = 409
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 410
                self.importPath()
                self.state = 411
                self.eos()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ImportPathContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def StringLiteralFragment(self):
            return self.getToken(SolidityParser.StringLiteralFragment, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_importPath

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterImportPath" ):
                listener.enterImportPath(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitImportPath" ):
                listener.exitImportPath(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitImportPath" ):
                return visitor.visitImportPath(self)
            else:
                return visitor.visitChildren(self)




    def importPath(self):

        localctx = SolidityParser.ImportPathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_importPath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 415
            self.match(SolidityParser.StringLiteralFragment)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ContractDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def inheritanceSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.InheritanceSpecifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.InheritanceSpecifierContext,i)


        def contractPart(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ContractPartContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ContractPartContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_contractDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterContractDefinition" ):
                listener.enterContractDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitContractDefinition" ):
                listener.exitContractDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitContractDefinition" ):
                return visitor.visitContractDefinition(self)
            else:
                return visitor.visitChildren(self)




    def contractDefinition(self):

        localctx = SolidityParser.ContractDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_contractDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 424
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==17:
                self.state = 417
                self.match(SolidityParser.T__16)
                self.state = 421
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 418
                    self.match(SolidityParser.NL)
                    self.state = 423
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 426
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 1835008) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 430
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 427
                self.match(SolidityParser.NL)
                self.state = 432
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 433
            self.identifier()
            self.state = 455
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==21:
                self.state = 434
                self.match(SolidityParser.T__20)
                self.state = 438
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 435
                    self.match(SolidityParser.NL)
                    self.state = 440
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 441
                self.inheritanceSpecifier()
                self.state = 452
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==15:
                    self.state = 442
                    self.match(SolidityParser.T__14)
                    self.state = 446
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 443
                        self.match(SolidityParser.NL)
                        self.state = 448
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 449
                    self.inheritanceSpecifier()
                    self.state = 454
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 457
            self.match(SolidityParser.T__13)
            self.state = 461
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 458
                self.match(SolidityParser.NL)
                self.state = 463
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 467
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 13)) & ~0x3f) == 0 and ((1 << (_la - 13)) & 17451522874939393) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 16781672573) != 0):
                self.state = 464
                self.contractPart()
                self.state = 469
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 470
            self.match(SolidityParser.T__15)
            self.state = 474
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 471
                self.match(SolidityParser.NL)
                self.state = 476
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InheritanceSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def userDefinedTypeName(self):
            return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def expressionList(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_inheritanceSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInheritanceSpecifier" ):
                listener.enterInheritanceSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInheritanceSpecifier" ):
                listener.exitInheritanceSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInheritanceSpecifier" ):
                return visitor.visitInheritanceSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def inheritanceSpecifier(self):

        localctx = SolidityParser.InheritanceSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_inheritanceSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 477
            self.userDefinedTypeName()
            self.state = 495
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==22:
                self.state = 478
                self.match(SolidityParser.T__21)
                self.state = 482
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 479
                    self.match(SolidityParser.NL)
                    self.state = 484
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 486
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 5)) & ~0x3f) == 0 and ((1 << (_la - 5)) & -144096148434845439) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & 2135005496493473805) != 0):
                    self.state = 485
                    self.expressionList()


                self.state = 488
                self.match(SolidityParser.T__22)
                self.state = 492
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 489
                    self.match(SolidityParser.NL)
                    self.state = 494
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ContractPartContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def stateVariableDeclaration(self):
            return self.getTypedRuleContext(SolidityParser.StateVariableDeclarationContext,0)


        def usingForDeclaration(self):
            return self.getTypedRuleContext(SolidityParser.UsingForDeclarationContext,0)


        def structDefinition(self):
            return self.getTypedRuleContext(SolidityParser.StructDefinitionContext,0)


        def modifierDefinition(self):
            return self.getTypedRuleContext(SolidityParser.ModifierDefinitionContext,0)


        def functionDefinition(self):
            return self.getTypedRuleContext(SolidityParser.FunctionDefinitionContext,0)


        def eventDefinition(self):
            return self.getTypedRuleContext(SolidityParser.EventDefinitionContext,0)


        def enumDefinition(self):
            return self.getTypedRuleContext(SolidityParser.EnumDefinitionContext,0)


        def customErrorDefinition(self):
            return self.getTypedRuleContext(SolidityParser.CustomErrorDefinitionContext,0)


        def typeDefinition(self):
            return self.getTypedRuleContext(SolidityParser.TypeDefinitionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_contractPart

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterContractPart" ):
                listener.enterContractPart(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitContractPart" ):
                listener.exitContractPart(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitContractPart" ):
                return visitor.visitContractPart(self)
            else:
                return visitor.visitChildren(self)




    def contractPart(self):

        localctx = SolidityParser.ContractPartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_contractPart)
        try:
            self.state = 506
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 497
                self.stateVariableDeclaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 498
                self.usingForDeclaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 499
                self.structDefinition()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 500
                self.modifierDefinition()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 501
                self.functionDefinition()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 502
                self.eventDefinition()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 503
                self.enumDefinition()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 504
                self.customErrorDefinition()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 505
                self.typeDefinition()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StateVariableDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def PublicKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.PublicKeyword)
            else:
                return self.getToken(SolidityParser.PublicKeyword, i)

        def InternalKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.InternalKeyword)
            else:
                return self.getToken(SolidityParser.InternalKeyword, i)

        def PrivateKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.PrivateKeyword)
            else:
                return self.getToken(SolidityParser.PrivateKeyword, i)

        def ConstantKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.ConstantKeyword)
            else:
                return self.getToken(SolidityParser.ConstantKeyword, i)

        def ImmutableKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.ImmutableKeyword)
            else:
                return self.getToken(SolidityParser.ImmutableKeyword, i)

        def overrideSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.OverrideSpecifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.OverrideSpecifierContext,i)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_stateVariableDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStateVariableDeclaration" ):
                listener.enterStateVariableDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStateVariableDeclaration" ):
                listener.exitStateVariableDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStateVariableDeclaration" ):
                return visitor.visitStateVariableDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def stateVariableDeclaration(self):

        localctx = SolidityParser.StateVariableDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_stateVariableDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 508
            self.typeName(0)
            self.state = 547
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & 13680641) != 0):
                self.state = 545
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [119]:
                    self.state = 509
                    self.match(SolidityParser.PublicKeyword)
                    self.state = 513
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 510
                        self.match(SolidityParser.NL)
                        self.state = 515
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass
                elif token in [116]:
                    self.state = 516
                    self.match(SolidityParser.InternalKeyword)
                    self.state = 520
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 517
                        self.match(SolidityParser.NL)
                        self.state = 522
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass
                elif token in [118]:
                    self.state = 523
                    self.match(SolidityParser.PrivateKeyword)
                    self.state = 527
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 524
                        self.match(SolidityParser.NL)
                        self.state = 529
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass
                elif token in [110]:
                    self.state = 530
                    self.match(SolidityParser.ConstantKeyword)
                    self.state = 534
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 531
                        self.match(SolidityParser.NL)
                        self.state = 536
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass
                elif token in [111]:
                    self.state = 537
                    self.match(SolidityParser.ImmutableKeyword)
                    self.state = 541
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 538
                        self.match(SolidityParser.NL)
                        self.state = 543
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass
                elif token in [96]:
                    self.state = 544
                    self.overrideSpecifier()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 549
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 550
            self.identifier()
            self.state = 559
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==10:
                self.state = 551
                self.match(SolidityParser.T__9)
                self.state = 555
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 552
                    self.match(SolidityParser.NL)
                    self.state = 557
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 558
                self.expression(0)


            self.state = 561
            self.eos()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FileLevelConstantContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def ConstantKeyword(self):
            return self.getToken(SolidityParser.ConstantKeyword, 0)

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_fileLevelConstant

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFileLevelConstant" ):
                listener.enterFileLevelConstant(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFileLevelConstant" ):
                listener.exitFileLevelConstant(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFileLevelConstant" ):
                return visitor.visitFileLevelConstant(self)
            else:
                return visitor.visitChildren(self)




    def fileLevelConstant(self):

        localctx = SolidityParser.FileLevelConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_fileLevelConstant)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 563
            self.typeName(0)
            self.state = 564
            self.match(SolidityParser.ConstantKeyword)
            self.state = 568
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 565
                self.match(SolidityParser.NL)
                self.state = 570
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 571
            self.identifier()
            self.state = 572
            self.match(SolidityParser.T__9)
            self.state = 576
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 573
                self.match(SolidityParser.NL)
                self.state = 578
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 579
            self.expression(0)
            self.state = 580
            self.eos()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CustomErrorDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def parameterList(self):
            return self.getTypedRuleContext(SolidityParser.ParameterListContext,0)


        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_customErrorDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCustomErrorDefinition" ):
                listener.enterCustomErrorDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCustomErrorDefinition" ):
                listener.exitCustomErrorDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCustomErrorDefinition" ):
                return visitor.visitCustomErrorDefinition(self)
            else:
                return visitor.visitChildren(self)




    def customErrorDefinition(self):

        localctx = SolidityParser.CustomErrorDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_customErrorDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 582
            self.match(SolidityParser.T__23)
            self.state = 586
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 583
                self.match(SolidityParser.NL)
                self.state = 588
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 589
            self.identifier()
            self.state = 590
            self.parameterList()
            self.state = 591
            self.eos()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TypeKeyword(self):
            return self.getToken(SolidityParser.TypeKeyword, 0)

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def elementaryTypeName(self):
            return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext,0)


        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_typeDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeDefinition" ):
                listener.enterTypeDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeDefinition" ):
                listener.exitTypeDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeDefinition" ):
                return visitor.visitTypeDefinition(self)
            else:
                return visitor.visitChildren(self)




    def typeDefinition(self):

        localctx = SolidityParser.TypeDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_typeDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 593
            self.match(SolidityParser.TypeKeyword)
            self.state = 597
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 594
                self.match(SolidityParser.NL)
                self.state = 599
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 600
            self.identifier()
            self.state = 601
            self.match(SolidityParser.T__20)
            self.state = 605
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 602
                self.match(SolidityParser.NL)
                self.state = 607
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 608
            self.elementaryTypeName()
            self.state = 609
            self.eos()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UsingForDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def usingForObject(self):
            return self.getTypedRuleContext(SolidityParser.UsingForObjectContext,0)


        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def GlobalKeyword(self):
            return self.getToken(SolidityParser.GlobalKeyword, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_usingForDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUsingForDeclaration" ):
                listener.enterUsingForDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUsingForDeclaration" ):
                listener.exitUsingForDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUsingForDeclaration" ):
                return visitor.visitUsingForDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def usingForDeclaration(self):

        localctx = SolidityParser.UsingForDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_usingForDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 611
            self.match(SolidityParser.T__24)
            self.state = 615
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 612
                self.match(SolidityParser.NL)
                self.state = 617
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 618
            self.usingForObject()
            self.state = 619
            self.match(SolidityParser.T__25)
            self.state = 623
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 620
                self.match(SolidityParser.NL)
                self.state = 625
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 634
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [2]:
                self.state = 626
                self.match(SolidityParser.T__1)
                self.state = 630
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,64,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 627
                        self.match(SolidityParser.NL) 
                    self.state = 632
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,64,self._ctx)

                pass
            elif token in [13, 24, 37, 43, 45, 49, 62, 63, 64, 65, 66, 95, 97, 98, 99, 100, 101, 113, 117, 124, 125, 127, 128]:
                self.state = 633
                self.typeName(0)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 643
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==124:
                self.state = 636
                self.match(SolidityParser.GlobalKeyword)
                self.state = 640
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,66,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 637
                        self.match(SolidityParser.NL) 
                    self.state = 642
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,66,self._ctx)



            self.state = 645
            self.eos()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UsingForObjectContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def userDefinedTypeName(self):
            return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0)


        def usingForObjectDirective(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.UsingForObjectDirectiveContext)
            else:
                return self.getTypedRuleContext(SolidityParser.UsingForObjectDirectiveContext,i)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_usingForObject

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUsingForObject" ):
                listener.enterUsingForObject(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUsingForObject" ):
                listener.exitUsingForObject(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUsingForObject" ):
                return visitor.visitUsingForObject(self)
            else:
                return visitor.visitChildren(self)




    def usingForObject(self):

        localctx = SolidityParser.UsingForObjectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_usingForObject)
        self._la = 0 # Token type
        try:
            self.state = 676
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [13, 24, 43, 49, 62, 95, 113, 117, 124, 125, 127, 128]:
                self.enterOuterAlt(localctx, 1)
                self.state = 647
                self.userDefinedTypeName()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 2)
                self.state = 648
                self.match(SolidityParser.T__13)
                self.state = 652
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 649
                    self.match(SolidityParser.NL)
                    self.state = 654
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 655
                self.usingForObjectDirective()
                self.state = 666
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==15:
                    self.state = 656
                    self.match(SolidityParser.T__14)
                    self.state = 660
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 657
                        self.match(SolidityParser.NL)
                        self.state = 662
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 663
                    self.usingForObjectDirective()
                    self.state = 668
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 669
                self.match(SolidityParser.T__15)
                self.state = 673
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 670
                    self.match(SolidityParser.NL)
                    self.state = 675
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UsingForObjectDirectiveContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def userDefinedTypeName(self):
            return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0)


        def userDefinableOperators(self):
            return self.getTypedRuleContext(SolidityParser.UserDefinableOperatorsContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_usingForObjectDirective

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUsingForObjectDirective" ):
                listener.enterUsingForObjectDirective(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUsingForObjectDirective" ):
                listener.exitUsingForObjectDirective(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUsingForObjectDirective" ):
                return visitor.visitUsingForObjectDirective(self)
            else:
                return visitor.visitChildren(self)




    def usingForObjectDirective(self):

        localctx = SolidityParser.UsingForObjectDirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_usingForObjectDirective)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 678
            self.userDefinedTypeName()
            self.state = 687
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==11:
                self.state = 679
                self.match(SolidityParser.T__10)
                self.state = 683
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 680
                    self.match(SolidityParser.NL)
                    self.state = 685
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 686
                self.userDefinableOperators()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UserDefinableOperatorsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_userDefinableOperators

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUserDefinableOperators" ):
                listener.enterUserDefinableOperators(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUserDefinableOperators" ):
                listener.exitUserDefinableOperators(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUserDefinableOperators" ):
                return visitor.visitUserDefinableOperators(self)
            else:
                return visitor.visitChildren(self)




    def userDefinableOperators(self):

        localctx = SolidityParser.UserDefinableOperatorsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_userDefinableOperators)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 689
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 34225521652) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 693
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 690
                self.match(SolidityParser.NL)
                self.state = 695
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StructDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def variableDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.VariableDeclarationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.VariableDeclarationContext,i)


        def eos(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.EosContext)
            else:
                return self.getTypedRuleContext(SolidityParser.EosContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_structDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStructDefinition" ):
                listener.enterStructDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStructDefinition" ):
                listener.exitStructDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStructDefinition" ):
                return visitor.visitStructDefinition(self)
            else:
                return visitor.visitChildren(self)




    def structDefinition(self):

        localctx = SolidityParser.StructDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_structDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 696
            self.match(SolidityParser.T__34)
            self.state = 700
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 697
                self.match(SolidityParser.NL)
                self.state = 702
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 703
            self.identifier()
            self.state = 704
            self.match(SolidityParser.T__13)
            self.state = 708
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 705
                self.match(SolidityParser.NL)
                self.state = 710
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 721
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 13)) & ~0x3f) == 0 and ((1 << (_la - 13)) & 17451522661025793) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971197) != 0):
                self.state = 711
                self.variableDeclaration()
                self.state = 712
                self.eos()
                self.state = 718
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while ((((_la - 13)) & ~0x3f) == 0 and ((1 << (_la - 13)) & 17451522661025793) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971197) != 0):
                    self.state = 713
                    self.variableDeclaration()
                    self.state = 714
                    self.eos()
                    self.state = 720
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 723
            self.match(SolidityParser.T__15)
            self.state = 727
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 724
                self.match(SolidityParser.NL)
                self.state = 729
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ModifierDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def parameterList(self):
            return self.getTypedRuleContext(SolidityParser.ParameterListContext,0)


        def VirtualKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.VirtualKeyword)
            else:
                return self.getToken(SolidityParser.VirtualKeyword, i)

        def overrideSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.OverrideSpecifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.OverrideSpecifierContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_modifierDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterModifierDefinition" ):
                listener.enterModifierDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitModifierDefinition" ):
                listener.exitModifierDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitModifierDefinition" ):
                return visitor.visitModifierDefinition(self)
            else:
                return visitor.visitChildren(self)




    def modifierDefinition(self):

        localctx = SolidityParser.ModifierDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_modifierDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 730
            self.match(SolidityParser.T__35)
            self.state = 734
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 731
                self.match(SolidityParser.NL)
                self.state = 736
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 737
            self.identifier()
            self.state = 739
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==22:
                self.state = 738
                self.parameterList()


            self.state = 751
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==96 or _la==120:
                self.state = 749
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [120]:
                    self.state = 741
                    self.match(SolidityParser.VirtualKeyword)
                    self.state = 745
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,83,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 742
                            self.match(SolidityParser.NL) 
                        self.state = 747
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,83,self._ctx)

                    pass
                elif token in [96]:
                    self.state = 748
                    self.overrideSpecifier()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 753
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 756
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [56, 131]:
                self.state = 754
                self.eos()
                pass
            elif token in [14]:
                self.state = 755
                self.block()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ModifierInvocationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def expressionList(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_modifierInvocation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterModifierInvocation" ):
                listener.enterModifierInvocation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitModifierInvocation" ):
                listener.exitModifierInvocation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitModifierInvocation" ):
                return visitor.visitModifierInvocation(self)
            else:
                return visitor.visitChildren(self)




    def modifierInvocation(self):

        localctx = SolidityParser.ModifierInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_modifierInvocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 758
            self.identifier()
            self.state = 776
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==22:
                self.state = 759
                self.match(SolidityParser.T__21)
                self.state = 763
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 760
                    self.match(SolidityParser.NL)
                    self.state = 765
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 767
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 5)) & ~0x3f) == 0 and ((1 << (_la - 5)) & -144096148434845439) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & 2135005496493473805) != 0):
                    self.state = 766
                    self.expressionList()


                self.state = 769
                self.match(SolidityParser.T__22)
                self.state = 773
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,89,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 770
                        self.match(SolidityParser.NL) 
                    self.state = 775
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,89,self._ctx)



        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def functionDescriptor(self):
            return self.getTypedRuleContext(SolidityParser.FunctionDescriptorContext,0)


        def parameterList(self):
            return self.getTypedRuleContext(SolidityParser.ParameterListContext,0)


        def modifierList(self):
            return self.getTypedRuleContext(SolidityParser.ModifierListContext,0)


        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def returnParameters(self):
            return self.getTypedRuleContext(SolidityParser.ReturnParametersContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionDefinition" ):
                listener.enterFunctionDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionDefinition" ):
                listener.exitFunctionDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionDefinition" ):
                return visitor.visitFunctionDefinition(self)
            else:
                return visitor.visitChildren(self)




    def functionDefinition(self):

        localctx = SolidityParser.FunctionDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_functionDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 778
            self.functionDescriptor()
            self.state = 779
            self.parameterList()
            self.state = 780
            self.modifierList()
            self.state = 782
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==38:
                self.state = 781
                self.returnParameters()


            self.state = 786
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [56, 131]:
                self.state = 784
                self.eos()
                pass
            elif token in [14]:
                self.state = 785
                self.block()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionDescriptorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def ConstructorKeyword(self):
            return self.getToken(SolidityParser.ConstructorKeyword, 0)

        def FallbackKeyword(self):
            return self.getToken(SolidityParser.FallbackKeyword, 0)

        def ReceiveKeyword(self):
            return self.getToken(SolidityParser.ReceiveKeyword, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_functionDescriptor

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionDescriptor" ):
                listener.enterFunctionDescriptor(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionDescriptor" ):
                listener.exitFunctionDescriptor(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionDescriptor" ):
                return visitor.visitFunctionDescriptor(self)
            else:
                return visitor.visitChildren(self)




    def functionDescriptor(self):

        localctx = SolidityParser.FunctionDescriptorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_functionDescriptor)
        self._la = 0 # Token type
        try:
            self.state = 819
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [37]:
                self.enterOuterAlt(localctx, 1)
                self.state = 788
                self.match(SolidityParser.T__36)
                self.state = 792
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 789
                    self.match(SolidityParser.NL)
                    self.state = 794
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 796
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4612257764490616832) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971073) != 0):
                    self.state = 795
                    self.identifier()


                pass
            elif token in [125]:
                self.enterOuterAlt(localctx, 2)
                self.state = 798
                self.match(SolidityParser.ConstructorKeyword)
                self.state = 802
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 799
                    self.match(SolidityParser.NL)
                    self.state = 804
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [126]:
                self.enterOuterAlt(localctx, 3)
                self.state = 805
                self.match(SolidityParser.FallbackKeyword)
                self.state = 809
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 806
                    self.match(SolidityParser.NL)
                    self.state = 811
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [127]:
                self.enterOuterAlt(localctx, 4)
                self.state = 812
                self.match(SolidityParser.ReceiveKeyword)
                self.state = 816
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 813
                    self.match(SolidityParser.NL)
                    self.state = 818
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReturnParametersContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def parameterList(self):
            return self.getTypedRuleContext(SolidityParser.ParameterListContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_returnParameters

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterReturnParameters" ):
                listener.enterReturnParameters(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitReturnParameters" ):
                listener.exitReturnParameters(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReturnParameters" ):
                return visitor.visitReturnParameters(self)
            else:
                return visitor.visitChildren(self)




    def returnParameters(self):

        localctx = SolidityParser.ReturnParametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_returnParameters)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 821
            self.match(SolidityParser.T__37)
            self.state = 825
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 822
                self.match(SolidityParser.NL)
                self.state = 827
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 828
            self.parameterList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ModifierListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ExternalKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.ExternalKeyword)
            else:
                return self.getToken(SolidityParser.ExternalKeyword, i)

        def PublicKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.PublicKeyword)
            else:
                return self.getToken(SolidityParser.PublicKeyword, i)

        def InternalKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.InternalKeyword)
            else:
                return self.getToken(SolidityParser.InternalKeyword, i)

        def PrivateKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.PrivateKeyword)
            else:
                return self.getToken(SolidityParser.PrivateKeyword, i)

        def VirtualKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.VirtualKeyword)
            else:
                return self.getToken(SolidityParser.VirtualKeyword, i)

        def stateMutability(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.StateMutabilityContext)
            else:
                return self.getTypedRuleContext(SolidityParser.StateMutabilityContext,i)


        def modifierInvocation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ModifierInvocationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ModifierInvocationContext,i)


        def overrideSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.OverrideSpecifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.OverrideSpecifierContext,i)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_modifierList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterModifierList" ):
                listener.enterModifierList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitModifierList" ):
                listener.exitModifierList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitModifierList" ):
                return visitor.visitModifierList(self)
            else:
                return visitor.visitChildren(self)




    def modifierList(self):

        localctx = SolidityParser.ModifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_modifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 870
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 4612257764490616832) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14896889859) != 0):
                self.state = 868
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,105,self._ctx)
                if la_ == 1:
                    self.state = 830
                    self.match(SolidityParser.ExternalKeyword)
                    self.state = 834
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,100,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 831
                            self.match(SolidityParser.NL) 
                        self.state = 836
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,100,self._ctx)

                    pass

                elif la_ == 2:
                    self.state = 837
                    self.match(SolidityParser.PublicKeyword)
                    self.state = 841
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,101,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 838
                            self.match(SolidityParser.NL) 
                        self.state = 843
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,101,self._ctx)

                    pass

                elif la_ == 3:
                    self.state = 844
                    self.match(SolidityParser.InternalKeyword)
                    self.state = 848
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,102,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 845
                            self.match(SolidityParser.NL) 
                        self.state = 850
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,102,self._ctx)

                    pass

                elif la_ == 4:
                    self.state = 851
                    self.match(SolidityParser.PrivateKeyword)
                    self.state = 855
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,103,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 852
                            self.match(SolidityParser.NL) 
                        self.state = 857
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,103,self._ctx)

                    pass

                elif la_ == 5:
                    self.state = 858
                    self.match(SolidityParser.VirtualKeyword)
                    self.state = 862
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,104,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 859
                            self.match(SolidityParser.NL) 
                        self.state = 864
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,104,self._ctx)

                    pass

                elif la_ == 6:
                    self.state = 865
                    self.stateMutability()
                    pass

                elif la_ == 7:
                    self.state = 866
                    self.modifierInvocation()
                    pass

                elif la_ == 8:
                    self.state = 867
                    self.overrideSpecifier()
                    pass


                self.state = 872
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EventDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def eventParameterList(self):
            return self.getTypedRuleContext(SolidityParser.EventParameterListContext,0)


        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def AnonymousKeyword(self):
            return self.getToken(SolidityParser.AnonymousKeyword, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_eventDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEventDefinition" ):
                listener.enterEventDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEventDefinition" ):
                listener.exitEventDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEventDefinition" ):
                return visitor.visitEventDefinition(self)
            else:
                return visitor.visitChildren(self)




    def eventDefinition(self):

        localctx = SolidityParser.EventDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_eventDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 873
            self.match(SolidityParser.T__38)
            self.state = 877
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 874
                self.match(SolidityParser.NL)
                self.state = 879
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 880
            self.identifier()
            self.state = 881
            self.eventParameterList()
            self.state = 889
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==108:
                self.state = 882
                self.match(SolidityParser.AnonymousKeyword)
                self.state = 886
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,108,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 883
                        self.match(SolidityParser.NL) 
                    self.state = 888
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,108,self._ctx)



            self.state = 891
            self.eos()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumValueContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_enumValue

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumValue" ):
                listener.enterEnumValue(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumValue" ):
                listener.exitEnumValue(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumValue" ):
                return visitor.visitEnumValue(self)
            else:
                return visitor.visitChildren(self)




    def enumValue(self):

        localctx = SolidityParser.EnumValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_enumValue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 893
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def enumValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.EnumValueContext)
            else:
                return self.getTypedRuleContext(SolidityParser.EnumValueContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_enumDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumDefinition" ):
                listener.enterEnumDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumDefinition" ):
                listener.exitEnumDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumDefinition" ):
                return visitor.visitEnumDefinition(self)
            else:
                return visitor.visitChildren(self)




    def enumDefinition(self):

        localctx = SolidityParser.EnumDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_enumDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 895
            self.match(SolidityParser.T__39)
            self.state = 899
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 896
                self.match(SolidityParser.NL)
                self.state = 901
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 902
            self.identifier()
            self.state = 903
            self.match(SolidityParser.T__13)
            self.state = 907
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 904
                self.match(SolidityParser.NL)
                self.state = 909
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 911
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4612257764490616832) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971073) != 0):
                self.state = 910
                self.enumValue()


            self.state = 923
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==15:
                self.state = 913
                self.match(SolidityParser.T__14)
                self.state = 917
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 914
                    self.match(SolidityParser.NL)
                    self.state = 919
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 920
                self.enumValue()
                self.state = 925
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 926
            self.match(SolidityParser.T__15)
            self.state = 930
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 927
                self.match(SolidityParser.NL)
                self.state = 932
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParameterListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def parameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ParameterContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ParameterContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_parameterList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParameterList" ):
                listener.enterParameterList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParameterList" ):
                listener.exitParameterList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParameterList" ):
                return visitor.visitParameterList(self)
            else:
                return visitor.visitChildren(self)




    def parameterList(self):

        localctx = SolidityParser.ParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_parameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 933
            self.match(SolidityParser.T__21)
            self.state = 937
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 934
                self.match(SolidityParser.NL)
                self.state = 939
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 954
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 13)) & ~0x3f) == 0 and ((1 << (_la - 13)) & 17451522661025793) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971197) != 0):
                self.state = 940
                self.parameter()
                self.state = 951
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==15:
                    self.state = 941
                    self.match(SolidityParser.T__14)
                    self.state = 945
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 942
                        self.match(SolidityParser.NL)
                        self.state = 947
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 948
                    self.parameter()
                    self.state = 953
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 956
            self.match(SolidityParser.T__22)
            self.state = 960
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,120,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 957
                    self.match(SolidityParser.NL) 
                self.state = 962
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,120,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParameterContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def storageLocation(self):
            return self.getTypedRuleContext(SolidityParser.StorageLocationContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_parameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParameter" ):
                listener.enterParameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParameter" ):
                listener.exitParameter(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParameter" ):
                return visitor.visitParameter(self)
            else:
                return visitor.visitChildren(self)




    def parameter(self):

        localctx = SolidityParser.ParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_parameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 963
            self.typeName(0)
            self.state = 965
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,121,self._ctx)
            if la_ == 1:
                self.state = 964
                self.storageLocation()


            self.state = 968
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4612257764490616832) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971073) != 0):
                self.state = 967
                self.identifier()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EventParameterListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def eventParameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.EventParameterContext)
            else:
                return self.getTypedRuleContext(SolidityParser.EventParameterContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_eventParameterList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEventParameterList" ):
                listener.enterEventParameterList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEventParameterList" ):
                listener.exitEventParameterList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEventParameterList" ):
                return visitor.visitEventParameterList(self)
            else:
                return visitor.visitChildren(self)




    def eventParameterList(self):

        localctx = SolidityParser.EventParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_eventParameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 970
            self.match(SolidityParser.T__21)
            self.state = 974
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 971
                self.match(SolidityParser.NL)
                self.state = 976
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 991
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 13)) & ~0x3f) == 0 and ((1 << (_la - 13)) & 17451522661025793) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971197) != 0):
                self.state = 977
                self.eventParameter()
                self.state = 988
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==15:
                    self.state = 978
                    self.match(SolidityParser.T__14)
                    self.state = 982
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 979
                        self.match(SolidityParser.NL)
                        self.state = 984
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 985
                    self.eventParameter()
                    self.state = 990
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 993
            self.match(SolidityParser.T__22)
            self.state = 997
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,127,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 994
                    self.match(SolidityParser.NL) 
                self.state = 999
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,127,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EventParameterContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def IndexedKeyword(self):
            return self.getToken(SolidityParser.IndexedKeyword, 0)

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_eventParameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEventParameter" ):
                listener.enterEventParameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEventParameter" ):
                listener.exitEventParameter(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEventParameter" ):
                return visitor.visitEventParameter(self)
            else:
                return visitor.visitChildren(self)




    def eventParameter(self):

        localctx = SolidityParser.EventParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_eventParameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1000
            self.typeName(0)
            self.state = 1008
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==115:
                self.state = 1001
                self.match(SolidityParser.IndexedKeyword)
                self.state = 1005
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1002
                    self.match(SolidityParser.NL)
                    self.state = 1007
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 1011
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4612257764490616832) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971073) != 0):
                self.state = 1010
                self.identifier()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionTypeParameterListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def functionTypeParameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.FunctionTypeParameterContext)
            else:
                return self.getTypedRuleContext(SolidityParser.FunctionTypeParameterContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionTypeParameterList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionTypeParameterList" ):
                listener.enterFunctionTypeParameterList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionTypeParameterList" ):
                listener.exitFunctionTypeParameterList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionTypeParameterList" ):
                return visitor.visitFunctionTypeParameterList(self)
            else:
                return visitor.visitChildren(self)




    def functionTypeParameterList(self):

        localctx = SolidityParser.FunctionTypeParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_functionTypeParameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1013
            self.match(SolidityParser.T__21)
            self.state = 1017
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1014
                self.match(SolidityParser.NL)
                self.state = 1019
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1034
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 13)) & ~0x3f) == 0 and ((1 << (_la - 13)) & 17451522661025793) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971197) != 0):
                self.state = 1020
                self.functionTypeParameter()
                self.state = 1031
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==15:
                    self.state = 1021
                    self.match(SolidityParser.T__14)
                    self.state = 1025
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 1022
                        self.match(SolidityParser.NL)
                        self.state = 1027
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1028
                    self.functionTypeParameter()
                    self.state = 1033
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 1036
            self.match(SolidityParser.T__22)
            self.state = 1040
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,135,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1037
                    self.match(SolidityParser.NL) 
                self.state = 1042
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,135,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionTypeParameterContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def storageLocation(self):
            return self.getTypedRuleContext(SolidityParser.StorageLocationContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionTypeParameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionTypeParameter" ):
                listener.enterFunctionTypeParameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionTypeParameter" ):
                listener.exitFunctionTypeParameter(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionTypeParameter" ):
                return visitor.visitFunctionTypeParameter(self)
            else:
                return visitor.visitChildren(self)




    def functionTypeParameter(self):

        localctx = SolidityParser.FunctionTypeParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_functionTypeParameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1043
            self.typeName(0)
            self.state = 1045
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 985162418487296) != 0):
                self.state = 1044
                self.storageLocation()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariableDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def storageLocation(self):
            return self.getTypedRuleContext(SolidityParser.StorageLocationContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_variableDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariableDeclaration" ):
                listener.enterVariableDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariableDeclaration" ):
                listener.exitVariableDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVariableDeclaration" ):
                return visitor.visitVariableDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def variableDeclaration(self):

        localctx = SolidityParser.VariableDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_variableDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1047
            self.typeName(0)
            self.state = 1049
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,137,self._ctx)
            if la_ == 1:
                self.state = 1048
                self.storageLocation()


            self.state = 1051
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def elementaryTypeName(self):
            return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext,0)


        def userDefinedTypeName(self):
            return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0)


        def mapping(self):
            return self.getTypedRuleContext(SolidityParser.MappingContext,0)


        def functionTypeName(self):
            return self.getTypedRuleContext(SolidityParser.FunctionTypeNameContext,0)


        def PayableKeyword(self):
            return self.getToken(SolidityParser.PayableKeyword, 0)

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_typeName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeName" ):
                listener.enterTypeName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeName" ):
                listener.exitTypeName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeName" ):
                return visitor.visitTypeName(self)
            else:
                return visitor.visitChildren(self)



    def typeName(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SolidityParser.TypeNameContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 76
        self.enterRecursionRule(localctx, 76, self.RULE_typeName, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1072
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,140,self._ctx)
            if la_ == 1:
                self.state = 1054
                self.elementaryTypeName()
                pass

            elif la_ == 2:
                self.state = 1055
                self.userDefinedTypeName()
                pass

            elif la_ == 3:
                self.state = 1056
                self.mapping()
                pass

            elif la_ == 4:
                self.state = 1057
                self.functionTypeName()
                pass

            elif la_ == 5:
                self.state = 1058
                self.match(SolidityParser.T__42)
                self.state = 1062
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1059
                    self.match(SolidityParser.NL)
                    self.state = 1064
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1065
                self.match(SolidityParser.PayableKeyword)
                self.state = 1069
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,139,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1066
                        self.match(SolidityParser.NL) 
                    self.state = 1071
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,139,self._ctx)

                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 1094
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,144,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = SolidityParser.TypeNameContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_typeName)
                    self.state = 1074
                    if not self.precpred(self._ctx, 3):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                    self.state = 1075
                    self.match(SolidityParser.T__40)
                    self.state = 1079
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 1076
                        self.match(SolidityParser.NL)
                        self.state = 1081
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1083
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if ((((_la - 5)) & ~0x3f) == 0 and ((1 << (_la - 5)) & -144096148434845439) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & 2135005496493473805) != 0):
                        self.state = 1082
                        self.expression(0)


                    self.state = 1085
                    self.match(SolidityParser.T__41)
                    self.state = 1089
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,143,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 1086
                            self.match(SolidityParser.NL) 
                        self.state = 1091
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,143,self._ctx)
             
                self.state = 1096
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,144,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class UserDefinedTypeNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_userDefinedTypeName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUserDefinedTypeName" ):
                listener.enterUserDefinedTypeName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUserDefinedTypeName" ):
                listener.exitUserDefinedTypeName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUserDefinedTypeName" ):
                return visitor.visitUserDefinedTypeName(self)
            else:
                return visitor.visitChildren(self)




    def userDefinedTypeName(self):

        localctx = SolidityParser.UserDefinedTypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_userDefinedTypeName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1097
            self.identifier()
            self.state = 1108
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,146,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1098
                    self.match(SolidityParser.T__43)
                    self.state = 1102
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 1099
                        self.match(SolidityParser.NL)
                        self.state = 1104
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1105
                    self.identifier() 
                self.state = 1110
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,146,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MappingKeyContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def elementaryTypeName(self):
            return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext,0)


        def userDefinedTypeName(self):
            return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_mappingKey

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMappingKey" ):
                listener.enterMappingKey(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMappingKey" ):
                listener.exitMappingKey(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMappingKey" ):
                return visitor.visitMappingKey(self)
            else:
                return visitor.visitChildren(self)




    def mappingKey(self):

        localctx = SolidityParser.MappingKeyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_mappingKey)
        try:
            self.state = 1113
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,147,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1111
                self.elementaryTypeName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1112
                self.userDefinedTypeName()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MappingContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def mappingKey(self):
            return self.getTypedRuleContext(SolidityParser.MappingKeyContext,0)


        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def mappingKeyName(self):
            return self.getTypedRuleContext(SolidityParser.MappingKeyNameContext,0)


        def mappingValueName(self):
            return self.getTypedRuleContext(SolidityParser.MappingValueNameContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_mapping

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMapping" ):
                listener.enterMapping(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMapping" ):
                listener.exitMapping(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMapping" ):
                return visitor.visitMapping(self)
            else:
                return visitor.visitChildren(self)




    def mapping(self):

        localctx = SolidityParser.MappingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_mapping)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1115
            self.match(SolidityParser.T__44)
            self.state = 1119
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1116
                self.match(SolidityParser.NL)
                self.state = 1121
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1122
            self.match(SolidityParser.T__21)
            self.state = 1126
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1123
                self.match(SolidityParser.NL)
                self.state = 1128
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1129
            self.mappingKey()
            self.state = 1131
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4612257764490616832) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971073) != 0):
                self.state = 1130
                self.mappingKeyName()


            self.state = 1133
            self.match(SolidityParser.T__45)
            self.state = 1137
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1134
                self.match(SolidityParser.NL)
                self.state = 1139
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1140
            self.typeName(0)
            self.state = 1142
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4612257764490616832) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971073) != 0):
                self.state = 1141
                self.mappingValueName()


            self.state = 1144
            self.match(SolidityParser.T__22)
            self.state = 1148
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,153,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1145
                    self.match(SolidityParser.NL) 
                self.state = 1150
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,153,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MappingKeyNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_mappingKeyName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMappingKeyName" ):
                listener.enterMappingKeyName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMappingKeyName" ):
                listener.exitMappingKeyName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMappingKeyName" ):
                return visitor.visitMappingKeyName(self)
            else:
                return visitor.visitChildren(self)




    def mappingKeyName(self):

        localctx = SolidityParser.MappingKeyNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_mappingKeyName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1151
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MappingValueNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_mappingValueName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMappingValueName" ):
                listener.enterMappingValueName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMappingValueName" ):
                listener.exitMappingValueName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMappingValueName" ):
                return visitor.visitMappingValueName(self)
            else:
                return visitor.visitChildren(self)




    def mappingValueName(self):

        localctx = SolidityParser.MappingValueNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_mappingValueName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1153
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionTypeNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def functionTypeParameterList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.FunctionTypeParameterListContext)
            else:
                return self.getTypedRuleContext(SolidityParser.FunctionTypeParameterListContext,i)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def InternalKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.InternalKeyword)
            else:
                return self.getToken(SolidityParser.InternalKeyword, i)

        def ExternalKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.ExternalKeyword)
            else:
                return self.getToken(SolidityParser.ExternalKeyword, i)

        def stateMutability(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.StateMutabilityContext)
            else:
                return self.getTypedRuleContext(SolidityParser.StateMutabilityContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionTypeName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionTypeName" ):
                listener.enterFunctionTypeName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionTypeName" ):
                listener.exitFunctionTypeName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionTypeName" ):
                return visitor.visitFunctionTypeName(self)
            else:
                return visitor.visitChildren(self)




    def functionTypeName(self):

        localctx = SolidityParser.FunctionTypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_functionTypeName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1155
            self.match(SolidityParser.T__36)
            self.state = 1159
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1156
                self.match(SolidityParser.NL)
                self.state = 1161
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1162
            self.functionTypeParameterList()
            self.state = 1180
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,158,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1178
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [116]:
                        self.state = 1163
                        self.match(SolidityParser.InternalKeyword)
                        self.state = 1167
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,155,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 1164
                                self.match(SolidityParser.NL) 
                            self.state = 1169
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,155,self._ctx)

                        pass
                    elif token in [114]:
                        self.state = 1170
                        self.match(SolidityParser.ExternalKeyword)
                        self.state = 1174
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,156,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 1171
                                self.match(SolidityParser.NL) 
                            self.state = 1176
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,156,self._ctx)

                        pass
                    elif token in [110, 117, 121, 123]:
                        self.state = 1177
                        self.stateMutability()
                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 1182
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,158,self._ctx)

            self.state = 1191
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,160,self._ctx)
            if la_ == 1:
                self.state = 1183
                self.match(SolidityParser.T__37)
                self.state = 1187
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1184
                    self.match(SolidityParser.NL)
                    self.state = 1189
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1190
                self.functionTypeParameterList()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StorageLocationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_storageLocation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStorageLocation" ):
                listener.enterStorageLocation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStorageLocation" ):
                listener.exitStorageLocation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStorageLocation" ):
                return visitor.visitStorageLocation(self)
            else:
                return visitor.visitChildren(self)




    def storageLocation(self):

        localctx = SolidityParser.StorageLocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_storageLocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1193
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 985162418487296) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1197
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1194
                self.match(SolidityParser.NL)
                self.state = 1199
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StateMutabilityContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PureKeyword(self):
            return self.getToken(SolidityParser.PureKeyword, 0)

        def ConstantKeyword(self):
            return self.getToken(SolidityParser.ConstantKeyword, 0)

        def ViewKeyword(self):
            return self.getToken(SolidityParser.ViewKeyword, 0)

        def PayableKeyword(self):
            return self.getToken(SolidityParser.PayableKeyword, 0)

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_stateMutability

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStateMutability" ):
                listener.enterStateMutability(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStateMutability" ):
                listener.exitStateMutability(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStateMutability" ):
                return visitor.visitStateMutability(self)
            else:
                return visitor.visitChildren(self)




    def stateMutability(self):

        localctx = SolidityParser.StateMutabilityContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_stateMutability)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1200
            _la = self._input.LA(1)
            if not(((((_la - 110)) & ~0x3f) == 0 and ((1 << (_la - 110)) & 10369) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1204
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,162,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1201
                    self.match(SolidityParser.NL) 
                self.state = 1206
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,162,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BlockContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.StatementContext)
            else:
                return self.getTypedRuleContext(SolidityParser.StatementContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_block

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBlock" ):
                listener.enterBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBlock" ):
                listener.exitBlock(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBlock" ):
                return visitor.visitBlock(self)
            else:
                return visitor.visitChildren(self)




    def block(self):

        localctx = SolidityParser.BlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_block)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1207
            self.match(SolidityParser.T__13)
            self.state = 1211
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1208
                self.match(SolidityParser.NL)
                self.state = 1213
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1217
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 5)) & ~0x3f) == 0 and ((1 << (_la - 5)) & -2619788263554303) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & 2135015392098123789) != 0):
                self.state = 1214
                self.statement()
                self.state = 1219
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1220
            self.match(SolidityParser.T__15)
            self.state = 1224
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1221
                self.match(SolidityParser.NL)
                self.state = 1226
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ifStatement(self):
            return self.getTypedRuleContext(SolidityParser.IfStatementContext,0)


        def tryStatement(self):
            return self.getTypedRuleContext(SolidityParser.TryStatementContext,0)


        def whileStatement(self):
            return self.getTypedRuleContext(SolidityParser.WhileStatementContext,0)


        def forStatement(self):
            return self.getTypedRuleContext(SolidityParser.ForStatementContext,0)


        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def inlineAssemblyStatement(self):
            return self.getTypedRuleContext(SolidityParser.InlineAssemblyStatementContext,0)


        def doWhileStatement(self):
            return self.getTypedRuleContext(SolidityParser.DoWhileStatementContext,0)


        def continueStatement(self):
            return self.getTypedRuleContext(SolidityParser.ContinueStatementContext,0)


        def breakStatement(self):
            return self.getTypedRuleContext(SolidityParser.BreakStatementContext,0)


        def returnStatement(self):
            return self.getTypedRuleContext(SolidityParser.ReturnStatementContext,0)


        def throwStatement(self):
            return self.getTypedRuleContext(SolidityParser.ThrowStatementContext,0)


        def emitStatement(self):
            return self.getTypedRuleContext(SolidityParser.EmitStatementContext,0)


        def simpleStatement(self):
            return self.getTypedRuleContext(SolidityParser.SimpleStatementContext,0)


        def uncheckedStatement(self):
            return self.getTypedRuleContext(SolidityParser.UncheckedStatementContext,0)


        def revertStatement(self):
            return self.getTypedRuleContext(SolidityParser.RevertStatementContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStatement" ):
                listener.enterStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStatement" ):
                listener.exitStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStatement" ):
                return visitor.visitStatement(self)
            else:
                return visitor.visitChildren(self)




    def statement(self):

        localctx = SolidityParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_statement)
        try:
            self.state = 1242
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,166,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1227
                self.ifStatement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1228
                self.tryStatement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1229
                self.whileStatement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1230
                self.forStatement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1231
                self.block()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1232
                self.inlineAssemblyStatement()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1233
                self.doWhileStatement()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1234
                self.continueStatement()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1235
                self.breakStatement()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1236
                self.returnStatement()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1237
                self.throwStatement()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1238
                self.emitStatement()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1239
                self.simpleStatement()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 1240
                self.uncheckedStatement()
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 1241
                self.revertStatement()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_expressionStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpressionStatement" ):
                listener.enterExpressionStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpressionStatement" ):
                listener.exitExpressionStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpressionStatement" ):
                return visitor.visitExpressionStatement(self)
            else:
                return visitor.visitChildren(self)




    def expressionStatement(self):

        localctx = SolidityParser.ExpressionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_expressionStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1244
            self.expression(0)
            self.state = 1245
            self.eos()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IfStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.StatementContext)
            else:
                return self.getTypedRuleContext(SolidityParser.StatementContext,i)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_ifStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIfStatement" ):
                listener.enterIfStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIfStatement" ):
                listener.exitIfStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIfStatement" ):
                return visitor.visitIfStatement(self)
            else:
                return visitor.visitChildren(self)




    def ifStatement(self):

        localctx = SolidityParser.IfStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_ifStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1247
            self.match(SolidityParser.T__49)
            self.state = 1251
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1248
                self.match(SolidityParser.NL)
                self.state = 1253
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1254
            self.match(SolidityParser.T__21)
            self.state = 1258
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1255
                self.match(SolidityParser.NL)
                self.state = 1260
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1261
            self.expression(0)
            self.state = 1262
            self.match(SolidityParser.T__22)
            self.state = 1266
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1263
                self.match(SolidityParser.NL)
                self.state = 1268
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1269
            self.statement()
            self.state = 1278
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,171,self._ctx)
            if la_ == 1:
                self.state = 1270
                self.match(SolidityParser.T__50)
                self.state = 1274
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1271
                    self.match(SolidityParser.NL)
                    self.state = 1276
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1277
                self.statement()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TryStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def returnParameters(self):
            return self.getTypedRuleContext(SolidityParser.ReturnParametersContext,0)


        def catchClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.CatchClauseContext)
            else:
                return self.getTypedRuleContext(SolidityParser.CatchClauseContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_tryStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTryStatement" ):
                listener.enterTryStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTryStatement" ):
                listener.exitTryStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTryStatement" ):
                return visitor.visitTryStatement(self)
            else:
                return visitor.visitChildren(self)




    def tryStatement(self):

        localctx = SolidityParser.TryStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_tryStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1280
            self.match(SolidityParser.T__51)
            self.state = 1284
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1281
                self.match(SolidityParser.NL)
                self.state = 1286
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1287
            self.expression(0)
            self.state = 1289
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==38:
                self.state = 1288
                self.returnParameters()


            self.state = 1291
            self.block()
            self.state = 1293 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1292
                self.catchClause()
                self.state = 1295 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==53):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CatchClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def parameterList(self):
            return self.getTypedRuleContext(SolidityParser.ParameterListContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_catchClause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCatchClause" ):
                listener.enterCatchClause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCatchClause" ):
                listener.exitCatchClause(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCatchClause" ):
                return visitor.visitCatchClause(self)
            else:
                return visitor.visitChildren(self)




    def catchClause(self):

        localctx = SolidityParser.CatchClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_catchClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1297
            self.match(SolidityParser.T__52)
            self.state = 1301
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1298
                self.match(SolidityParser.NL)
                self.state = 1303
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1308
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4612257764494811136) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971073) != 0):
                self.state = 1305
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4612257764490616832) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971073) != 0):
                    self.state = 1304
                    self.identifier()


                self.state = 1307
                self.parameterList()


            self.state = 1310
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WhileStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def statement(self):
            return self.getTypedRuleContext(SolidityParser.StatementContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_whileStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWhileStatement" ):
                listener.enterWhileStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWhileStatement" ):
                listener.exitWhileStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWhileStatement" ):
                return visitor.visitWhileStatement(self)
            else:
                return visitor.visitChildren(self)




    def whileStatement(self):

        localctx = SolidityParser.WhileStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_whileStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1312
            self.match(SolidityParser.T__53)
            self.state = 1316
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1313
                self.match(SolidityParser.NL)
                self.state = 1318
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1319
            self.match(SolidityParser.T__21)
            self.state = 1323
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1320
                self.match(SolidityParser.NL)
                self.state = 1325
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1326
            self.expression(0)
            self.state = 1327
            self.match(SolidityParser.T__22)
            self.state = 1331
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1328
                self.match(SolidityParser.NL)
                self.state = 1333
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1334
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SimpleStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def variableDeclarationStatement(self):
            return self.getTypedRuleContext(SolidityParser.VariableDeclarationStatementContext,0)


        def expressionStatement(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionStatementContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_simpleStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimpleStatement" ):
                listener.enterSimpleStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimpleStatement" ):
                listener.exitSimpleStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimpleStatement" ):
                return visitor.visitSimpleStatement(self)
            else:
                return visitor.visitChildren(self)




    def simpleStatement(self):

        localctx = SolidityParser.SimpleStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_simpleStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1338
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,181,self._ctx)
            if la_ == 1:
                self.state = 1336
                self.variableDeclarationStatement()
                pass

            elif la_ == 2:
                self.state = 1337
                self.expressionStatement()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UncheckedStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_uncheckedStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUncheckedStatement" ):
                listener.enterUncheckedStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUncheckedStatement" ):
                listener.exitUncheckedStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUncheckedStatement" ):
                return visitor.visitUncheckedStatement(self)
            else:
                return visitor.visitChildren(self)




    def uncheckedStatement(self):

        localctx = SolidityParser.UncheckedStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_uncheckedStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1340
            self.match(SolidityParser.T__54)
            self.state = 1344
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1341
                self.match(SolidityParser.NL)
                self.state = 1346
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1347
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ForStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def statement(self):
            return self.getTypedRuleContext(SolidityParser.StatementContext,0)


        def simpleStatement(self):
            return self.getTypedRuleContext(SolidityParser.SimpleStatementContext,0)


        def expressionStatement(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionStatementContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_forStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterForStatement" ):
                listener.enterForStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitForStatement" ):
                listener.exitForStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitForStatement" ):
                return visitor.visitForStatement(self)
            else:
                return visitor.visitChildren(self)




    def forStatement(self):

        localctx = SolidityParser.ForStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_forStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1349
            self.match(SolidityParser.T__25)
            self.state = 1353
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1350
                self.match(SolidityParser.NL)
                self.state = 1355
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1356
            self.match(SolidityParser.T__21)
            self.state = 1360
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1357
                self.match(SolidityParser.NL)
                self.state = 1362
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1371
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [5, 13, 22, 24, 29, 30, 37, 41, 43, 45, 49, 62, 63, 64, 65, 66, 67, 68, 69, 71, 72, 95, 97, 98, 99, 100, 101, 102, 103, 104, 106, 113, 117, 122, 124, 125, 127, 128, 129]:
                self.state = 1363
                self.simpleStatement()
                pass
            elif token in [56]:
                self.state = 1364
                self.match(SolidityParser.T__55)
                self.state = 1368
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1365
                    self.match(SolidityParser.NL)
                    self.state = 1370
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            else:
                raise NoViableAltException(self)

            self.state = 1381
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [5, 13, 22, 24, 29, 30, 37, 41, 43, 45, 49, 62, 63, 64, 65, 66, 67, 68, 69, 71, 72, 95, 97, 98, 99, 100, 101, 102, 103, 104, 106, 113, 117, 122, 124, 125, 127, 128, 129]:
                self.state = 1373
                self.expressionStatement()
                pass
            elif token in [56]:
                self.state = 1374
                self.match(SolidityParser.T__55)
                self.state = 1378
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1375
                    self.match(SolidityParser.NL)
                    self.state = 1380
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            else:
                raise NoViableAltException(self)

            self.state = 1384
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 5)) & ~0x3f) == 0 and ((1 << (_la - 5)) & -144096148434845439) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & 2135005496493473805) != 0):
                self.state = 1383
                self.expression(0)


            self.state = 1386
            self.match(SolidityParser.T__22)
            self.state = 1390
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1387
                self.match(SolidityParser.NL)
                self.state = 1392
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1393
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InlineAssemblyStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def StringLiteralFragment(self):
            return self.getToken(SolidityParser.StringLiteralFragment, 0)

        def inlineAssemblyStatementFlag(self):
            return self.getTypedRuleContext(SolidityParser.InlineAssemblyStatementFlagContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_inlineAssemblyStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInlineAssemblyStatement" ):
                listener.enterInlineAssemblyStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInlineAssemblyStatement" ):
                listener.exitInlineAssemblyStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInlineAssemblyStatement" ):
                return visitor.visitInlineAssemblyStatement(self)
            else:
                return visitor.visitChildren(self)




    def inlineAssemblyStatement(self):

        localctx = SolidityParser.InlineAssemblyStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_inlineAssemblyStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1395
            self.match(SolidityParser.T__56)
            self.state = 1399
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1396
                self.match(SolidityParser.NL)
                self.state = 1401
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1409
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==129:
                self.state = 1402
                self.match(SolidityParser.StringLiteralFragment)
                self.state = 1406
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1403
                    self.match(SolidityParser.NL)
                    self.state = 1408
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 1426
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==22:
                self.state = 1411
                self.match(SolidityParser.T__21)
                self.state = 1415
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1412
                    self.match(SolidityParser.NL)
                    self.state = 1417
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1418
                self.inlineAssemblyStatementFlag()
                self.state = 1419
                self.match(SolidityParser.T__22)
                self.state = 1423
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1420
                    self.match(SolidityParser.NL)
                    self.state = 1425
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 1428
            self.assemblyBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InlineAssemblyStatementFlagContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def stringLiteral(self):
            return self.getTypedRuleContext(SolidityParser.StringLiteralContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_inlineAssemblyStatementFlag

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInlineAssemblyStatementFlag" ):
                listener.enterInlineAssemblyStatementFlag(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInlineAssemblyStatementFlag" ):
                listener.exitInlineAssemblyStatementFlag(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInlineAssemblyStatementFlag" ):
                return visitor.visitInlineAssemblyStatementFlag(self)
            else:
                return visitor.visitChildren(self)




    def inlineAssemblyStatementFlag(self):

        localctx = SolidityParser.InlineAssemblyStatementFlagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_inlineAssemblyStatementFlag)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1430
            self.stringLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DoWhileStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def statement(self):
            return self.getTypedRuleContext(SolidityParser.StatementContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_doWhileStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDoWhileStatement" ):
                listener.enterDoWhileStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDoWhileStatement" ):
                listener.exitDoWhileStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDoWhileStatement" ):
                return visitor.visitDoWhileStatement(self)
            else:
                return visitor.visitChildren(self)




    def doWhileStatement(self):

        localctx = SolidityParser.DoWhileStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_doWhileStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1432
            self.match(SolidityParser.T__57)
            self.state = 1436
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1433
                self.match(SolidityParser.NL)
                self.state = 1438
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1439
            self.statement()
            self.state = 1440
            self.match(SolidityParser.T__53)
            self.state = 1444
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1441
                self.match(SolidityParser.NL)
                self.state = 1446
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1447
            self.match(SolidityParser.T__21)
            self.state = 1451
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1448
                self.match(SolidityParser.NL)
                self.state = 1453
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1454
            self.expression(0)
            self.state = 1455
            self.match(SolidityParser.T__22)
            self.state = 1456
            self.eos()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ContinueStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ContinueKeyword(self):
            return self.getToken(SolidityParser.ContinueKeyword, 0)

        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_continueStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterContinueStatement" ):
                listener.enterContinueStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitContinueStatement" ):
                listener.exitContinueStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitContinueStatement" ):
                return visitor.visitContinueStatement(self)
            else:
                return visitor.visitChildren(self)




    def continueStatement(self):

        localctx = SolidityParser.ContinueStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_continueStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1458
            self.match(SolidityParser.ContinueKeyword)
            self.state = 1459
            self.eos()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BreakStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def BreakKeyword(self):
            return self.getToken(SolidityParser.BreakKeyword, 0)

        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_breakStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBreakStatement" ):
                listener.enterBreakStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBreakStatement" ):
                listener.exitBreakStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBreakStatement" ):
                return visitor.visitBreakStatement(self)
            else:
                return visitor.visitChildren(self)




    def breakStatement(self):

        localctx = SolidityParser.BreakStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_breakStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1461
            self.match(SolidityParser.BreakKeyword)
            self.state = 1462
            self.eos()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReturnStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_returnStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterReturnStatement" ):
                listener.enterReturnStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitReturnStatement" ):
                listener.exitReturnStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReturnStatement" ):
                return visitor.visitReturnStatement(self)
            else:
                return visitor.visitChildren(self)




    def returnStatement(self):

        localctx = SolidityParser.ReturnStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_returnStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1464
            self.match(SolidityParser.T__58)
            self.state = 1468
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,200,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1465
                    self.match(SolidityParser.NL) 
                self.state = 1470
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,200,self._ctx)

            self.state = 1472
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 5)) & ~0x3f) == 0 and ((1 << (_la - 5)) & -144096148434845439) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & 2135005496493473805) != 0):
                self.state = 1471
                self.expression(0)


            self.state = 1474
            self.eos()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ThrowStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_throwStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterThrowStatement" ):
                listener.enterThrowStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitThrowStatement" ):
                listener.exitThrowStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitThrowStatement" ):
                return visitor.visitThrowStatement(self)
            else:
                return visitor.visitChildren(self)




    def throwStatement(self):

        localctx = SolidityParser.ThrowStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_throwStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1476
            self.match(SolidityParser.T__59)
            self.state = 1477
            self.eos()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EmitStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def functionCall(self):
            return self.getTypedRuleContext(SolidityParser.FunctionCallContext,0)


        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_emitStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEmitStatement" ):
                listener.enterEmitStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEmitStatement" ):
                listener.exitEmitStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEmitStatement" ):
                return visitor.visitEmitStatement(self)
            else:
                return visitor.visitChildren(self)




    def emitStatement(self):

        localctx = SolidityParser.EmitStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_emitStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1479
            self.match(SolidityParser.T__60)
            self.state = 1483
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1480
                self.match(SolidityParser.NL)
                self.state = 1485
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1486
            self.functionCall()
            self.state = 1487
            self.eos()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RevertStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def functionCall(self):
            return self.getTypedRuleContext(SolidityParser.FunctionCallContext,0)


        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_revertStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRevertStatement" ):
                listener.enterRevertStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRevertStatement" ):
                listener.exitRevertStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRevertStatement" ):
                return visitor.visitRevertStatement(self)
            else:
                return visitor.visitChildren(self)




    def revertStatement(self):

        localctx = SolidityParser.RevertStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_revertStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1489
            self.match(SolidityParser.T__61)
            self.state = 1493
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1490
                self.match(SolidityParser.NL)
                self.state = 1495
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1496
            self.functionCall()
            self.state = 1497
            self.eos()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariableDeclarationStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def eos(self):
            return self.getTypedRuleContext(SolidityParser.EosContext,0)


        def identifierList(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierListContext,0)


        def variableDeclaration(self):
            return self.getTypedRuleContext(SolidityParser.VariableDeclarationContext,0)


        def variableDeclarationList(self):
            return self.getTypedRuleContext(SolidityParser.VariableDeclarationListContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_variableDeclarationStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariableDeclarationStatement" ):
                listener.enterVariableDeclarationStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariableDeclarationStatement" ):
                listener.exitVariableDeclarationStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVariableDeclarationStatement" ):
                return visitor.visitVariableDeclarationStatement(self)
            else:
                return visitor.visitChildren(self)




    def variableDeclarationStatement(self):

        localctx = SolidityParser.VariableDeclarationStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_variableDeclarationStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1523
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,207,self._ctx)
            if la_ == 1:
                self.state = 1499
                self.match(SolidityParser.T__62)
                self.state = 1503
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1500
                    self.match(SolidityParser.NL)
                    self.state = 1505
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1506
                self.identifierList()
                pass

            elif la_ == 2:
                self.state = 1507
                self.variableDeclaration()
                pass

            elif la_ == 3:
                self.state = 1508
                self.match(SolidityParser.T__21)
                self.state = 1512
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1509
                    self.match(SolidityParser.NL)
                    self.state = 1514
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1515
                self.variableDeclarationList()
                self.state = 1516
                self.match(SolidityParser.T__22)
                self.state = 1520
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,206,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1517
                        self.match(SolidityParser.NL) 
                    self.state = 1522
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,206,self._ctx)

                pass


            self.state = 1533
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==10:
                self.state = 1525
                self.match(SolidityParser.T__9)
                self.state = 1529
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1526
                    self.match(SolidityParser.NL)
                    self.state = 1531
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1532
                self.expression(0)


            self.state = 1535
            self.eos()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariableDeclarationListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def variableDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.VariableDeclarationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.VariableDeclarationContext,i)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_variableDeclarationList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariableDeclarationList" ):
                listener.enterVariableDeclarationList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariableDeclarationList" ):
                listener.exitVariableDeclarationList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVariableDeclarationList" ):
                return visitor.visitVariableDeclarationList(self)
            else:
                return visitor.visitChildren(self)




    def variableDeclarationList(self):

        localctx = SolidityParser.VariableDeclarationListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_variableDeclarationList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1538
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 13)) & ~0x3f) == 0 and ((1 << (_la - 13)) & 17451522661025793) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971197) != 0):
                self.state = 1537
                self.variableDeclaration()


            self.state = 1552
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==15:
                self.state = 1540
                self.match(SolidityParser.T__14)
                self.state = 1544
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1541
                    self.match(SolidityParser.NL)
                    self.state = 1546
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1548
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 13)) & ~0x3f) == 0 and ((1 << (_la - 13)) & 17451522661025793) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971197) != 0):
                    self.state = 1547
                    self.variableDeclaration()


                self.state = 1554
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdentifierListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_identifierList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIdentifierList" ):
                listener.enterIdentifierList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIdentifierList" ):
                listener.exitIdentifierList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIdentifierList" ):
                return visitor.visitIdentifierList(self)
            else:
                return visitor.visitChildren(self)




    def identifierList(self):

        localctx = SolidityParser.IdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_identifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1555
            self.match(SolidityParser.T__21)
            self.state = 1559
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1556
                self.match(SolidityParser.NL)
                self.state = 1561
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1574
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,217,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1563
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4612257764490616832) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971073) != 0):
                        self.state = 1562
                        self.identifier()


                    self.state = 1565
                    self.match(SolidityParser.T__14)
                    self.state = 1569
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 1566
                        self.match(SolidityParser.NL)
                        self.state = 1571
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
             
                self.state = 1576
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,217,self._ctx)

            self.state = 1578
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4612257764490616832) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971073) != 0):
                self.state = 1577
                self.identifier()


            self.state = 1580
            self.match(SolidityParser.T__22)
            self.state = 1584
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,219,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1581
                    self.match(SolidityParser.NL) 
                self.state = 1586
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,219,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ElementaryTypeNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Int(self):
            return self.getToken(SolidityParser.Int, 0)

        def Uint(self):
            return self.getToken(SolidityParser.Uint, 0)

        def Byte(self):
            return self.getToken(SolidityParser.Byte, 0)

        def Fixed(self):
            return self.getToken(SolidityParser.Fixed, 0)

        def Ufixed(self):
            return self.getToken(SolidityParser.Ufixed, 0)

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_elementaryTypeName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterElementaryTypeName" ):
                listener.enterElementaryTypeName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitElementaryTypeName" ):
                listener.exitElementaryTypeName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitElementaryTypeName" ):
                return visitor.visitElementaryTypeName(self)
            else:
                return visitor.visitChildren(self)




    def elementaryTypeName(self):

        localctx = SolidityParser.ElementaryTypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_elementaryTypeName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1587
            _la = self._input.LA(1)
            if not(((((_la - 43)) & ~0x3f) == 0 and ((1 << (_la - 43)) & 558446353809670145) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1591
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,220,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1588
                    self.match(SolidityParser.NL) 
                self.state = 1593
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,220,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ExpressionContext,i)


        def primaryExpression(self):
            return self.getTypedRuleContext(SolidityParser.PrimaryExpressionContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def nameValueList(self):
            return self.getTypedRuleContext(SolidityParser.NameValueListContext,0)


        def functionCallArguments(self):
            return self.getTypedRuleContext(SolidityParser.FunctionCallArgumentsContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpression" ):
                listener.enterExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpression" ):
                listener.exitExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpression" ):
                return visitor.visitExpression(self)
            else:
                return visitor.visitChildren(self)



    def expression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SolidityParser.ExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 140
        self.enterRecursionRule(localctx, 140, self.RULE_expression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1659
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,229,self._ctx)
            if la_ == 1:
                self.state = 1595
                self.match(SolidityParser.T__68)
                self.state = 1599
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1596
                    self.match(SolidityParser.NL)
                    self.state = 1601
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1602
                self.typeName(0)
                pass

            elif la_ == 2:
                self.state = 1603
                self.match(SolidityParser.T__21)
                self.state = 1607
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1604
                    self.match(SolidityParser.NL)
                    self.state = 1609
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1610
                self.expression(0)
                self.state = 1611
                self.match(SolidityParser.T__22)
                self.state = 1615
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,223,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1612
                        self.match(SolidityParser.NL) 
                    self.state = 1617
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,223,self._ctx)

                pass

            elif la_ == 3:
                self.state = 1618
                _la = self._input.LA(1)
                if not(_la==67 or _la==68):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1622
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1619
                    self.match(SolidityParser.NL)
                    self.state = 1624
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1625
                self.expression(19)
                pass

            elif la_ == 4:
                self.state = 1626
                _la = self._input.LA(1)
                if not(_la==29 or _la==30):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1630
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1627
                    self.match(SolidityParser.NL)
                    self.state = 1632
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1633
                self.expression(18)
                pass

            elif la_ == 5:
                self.state = 1634
                self.match(SolidityParser.T__70)
                self.state = 1638
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1635
                    self.match(SolidityParser.NL)
                    self.state = 1640
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1641
                self.expression(17)
                pass

            elif la_ == 6:
                self.state = 1642
                self.match(SolidityParser.T__71)
                self.state = 1646
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1643
                    self.match(SolidityParser.NL)
                    self.state = 1648
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1649
                self.expression(16)
                pass

            elif la_ == 7:
                self.state = 1650
                self.match(SolidityParser.T__4)
                self.state = 1654
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1651
                    self.match(SolidityParser.NL)
                    self.state = 1656
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1657
                self.expression(15)
                pass

            elif la_ == 8:
                self.state = 1658
                self.primaryExpression()
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 1882
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,258,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 1880
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,257,self._ctx)
                    if la_ == 1:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1661
                        if not self.precpred(self._ctx, 14):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 14)")
                        self.state = 1662
                        self.match(SolidityParser.T__72)
                        self.state = 1666
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1663
                            self.match(SolidityParser.NL)
                            self.state = 1668
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1669
                        self.expression(15)
                        pass

                    elif la_ == 2:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1670
                        if not self.precpred(self._ctx, 13):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 13)")
                        self.state = 1671
                        _la = self._input.LA(1)
                        if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 6442450948) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1675
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1672
                            self.match(SolidityParser.NL)
                            self.state = 1677
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1678
                        self.expression(14)
                        pass

                    elif la_ == 3:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1679
                        if not self.precpred(self._ctx, 12):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
                        self.state = 1680
                        _la = self._input.LA(1)
                        if not(_la==29 or _la==30):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1684
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1681
                            self.match(SolidityParser.NL)
                            self.state = 1686
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1687
                        self.expression(13)
                        pass

                    elif la_ == 4:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1688
                        if not self.precpred(self._ctx, 11):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
                        self.state = 1689
                        _la = self._input.LA(1)
                        if not(_la==74 or _la==75):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1693
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1690
                            self.match(SolidityParser.NL)
                            self.state = 1695
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1696
                        self.expression(12)
                        pass

                    elif la_ == 5:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1697
                        if not self.precpred(self._ctx, 10):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
                        self.state = 1698
                        self.match(SolidityParser.T__27)
                        self.state = 1702
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1699
                            self.match(SolidityParser.NL)
                            self.state = 1704
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1705
                        self.expression(11)
                        pass

                    elif la_ == 6:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1706
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 1707
                        self.match(SolidityParser.T__3)
                        self.state = 1711
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1708
                            self.match(SolidityParser.NL)
                            self.state = 1713
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1714
                        self.expression(10)
                        pass

                    elif la_ == 7:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1715
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 1716
                        self.match(SolidityParser.T__26)
                        self.state = 1720
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1717
                            self.match(SolidityParser.NL)
                            self.state = 1722
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1723
                        self.expression(9)
                        pass

                    elif la_ == 8:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1724
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 1725
                        _la = self._input.LA(1)
                        if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 960) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1729
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1726
                            self.match(SolidityParser.NL)
                            self.state = 1731
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1732
                        self.expression(8)
                        pass

                    elif la_ == 9:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1733
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 1734
                        _la = self._input.LA(1)
                        if not(_la==33 or _la==34):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1738
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1735
                            self.match(SolidityParser.NL)
                            self.state = 1740
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1741
                        self.expression(7)
                        pass

                    elif la_ == 10:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1742
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 1743
                        self.match(SolidityParser.T__75)
                        self.state = 1747
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1744
                            self.match(SolidityParser.NL)
                            self.state = 1749
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1750
                        self.expression(6)
                        pass

                    elif la_ == 11:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1751
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 1752
                        self.match(SolidityParser.T__2)
                        self.state = 1756
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1753
                            self.match(SolidityParser.NL)
                            self.state = 1758
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1759
                        self.expression(5)
                        pass

                    elif la_ == 12:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1760
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 1761
                        self.match(SolidityParser.T__76)
                        self.state = 1765
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1762
                            self.match(SolidityParser.NL)
                            self.state = 1767
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1768
                        self.expression(0)
                        self.state = 1769
                        self.match(SolidityParser.T__69)
                        self.state = 1773
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1770
                            self.match(SolidityParser.NL)
                            self.state = 1775
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1776
                        self.expression(4)
                        pass

                    elif la_ == 13:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1778
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 1779
                        _la = self._input.LA(1)
                        if not(_la==10 or ((((_la - 78)) & ~0x3f) == 0 and ((1 << (_la - 78)) & 1023) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1783
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1780
                            self.match(SolidityParser.NL)
                            self.state = 1785
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1786
                        self.expression(3)
                        pass

                    elif la_ == 14:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1787
                        if not self.precpred(self._ctx, 27):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 27)")
                        self.state = 1788
                        _la = self._input.LA(1)
                        if not(_la==67 or _la==68):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1792
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,244,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 1789
                                self.match(SolidityParser.NL) 
                            self.state = 1794
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,244,self._ctx)

                        pass

                    elif la_ == 15:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1795
                        if not self.precpred(self._ctx, 25):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 25)")
                        self.state = 1796
                        self.match(SolidityParser.T__40)
                        self.state = 1800
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1797
                            self.match(SolidityParser.NL)
                            self.state = 1802
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1803
                        self.expression(0)
                        self.state = 1804
                        self.match(SolidityParser.T__41)
                        self.state = 1808
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,246,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 1805
                                self.match(SolidityParser.NL) 
                            self.state = 1810
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,246,self._ctx)

                        pass

                    elif la_ == 16:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1811
                        if not self.precpred(self._ctx, 24):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 24)")
                        self.state = 1812
                        self.match(SolidityParser.T__40)
                        self.state = 1816
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1813
                            self.match(SolidityParser.NL)
                            self.state = 1818
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1820
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if ((((_la - 5)) & ~0x3f) == 0 and ((1 << (_la - 5)) & -144096148434845439) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & 2135005496493473805) != 0):
                            self.state = 1819
                            self.expression(0)


                        self.state = 1822
                        self.match(SolidityParser.T__69)
                        self.state = 1826
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1823
                            self.match(SolidityParser.NL)
                            self.state = 1828
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1830
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if ((((_la - 5)) & ~0x3f) == 0 and ((1 << (_la - 5)) & -144096148434845439) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & 2135005496493473805) != 0):
                            self.state = 1829
                            self.expression(0)


                        self.state = 1832
                        self.match(SolidityParser.T__41)
                        self.state = 1836
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,251,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 1833
                                self.match(SolidityParser.NL) 
                            self.state = 1838
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,251,self._ctx)

                        pass

                    elif la_ == 17:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1839
                        if not self.precpred(self._ctx, 23):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 23)")
                        self.state = 1840
                        self.match(SolidityParser.T__43)
                        self.state = 1844
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1841
                            self.match(SolidityParser.NL)
                            self.state = 1846
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1847
                        self.identifier()
                        pass

                    elif la_ == 18:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1848
                        if not self.precpred(self._ctx, 22):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 22)")
                        self.state = 1849
                        self.match(SolidityParser.T__13)
                        self.state = 1853
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1850
                            self.match(SolidityParser.NL)
                            self.state = 1855
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1856
                        self.nameValueList()
                        self.state = 1857
                        self.match(SolidityParser.T__15)
                        self.state = 1861
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,254,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 1858
                                self.match(SolidityParser.NL) 
                            self.state = 1863
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,254,self._ctx)

                        pass

                    elif la_ == 19:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1864
                        if not self.precpred(self._ctx, 21):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 21)")
                        self.state = 1865
                        self.match(SolidityParser.T__21)
                        self.state = 1869
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 1866
                            self.match(SolidityParser.NL)
                            self.state = 1871
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1872
                        self.functionCallArguments()
                        self.state = 1873
                        self.match(SolidityParser.T__22)
                        self.state = 1877
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,256,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 1874
                                self.match(SolidityParser.NL) 
                            self.state = 1879
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,256,self._ctx)

                        pass

             
                self.state = 1884
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,258,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class PrimaryExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def BooleanLiteral(self):
            return self.getToken(SolidityParser.BooleanLiteral, 0)

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def numberLiteral(self):
            return self.getTypedRuleContext(SolidityParser.NumberLiteralContext,0)


        def hexLiteral(self):
            return self.getTypedRuleContext(SolidityParser.HexLiteralContext,0)


        def stringLiteral(self):
            return self.getTypedRuleContext(SolidityParser.StringLiteralContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def TypeKeyword(self):
            return self.getToken(SolidityParser.TypeKeyword, 0)

        def PayableKeyword(self):
            return self.getToken(SolidityParser.PayableKeyword, 0)

        def tupleExpression(self):
            return self.getTypedRuleContext(SolidityParser.TupleExpressionContext,0)


        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_primaryExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPrimaryExpression" ):
                listener.enterPrimaryExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPrimaryExpression" ):
                listener.exitPrimaryExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPrimaryExpression" ):
                return visitor.visitPrimaryExpression(self)
            else:
                return visitor.visitChildren(self)




    def primaryExpression(self):

        localctx = SolidityParser.PrimaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_primaryExpression)
        try:
            self.state = 1912
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,262,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1885
                self.match(SolidityParser.BooleanLiteral)
                self.state = 1889
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,259,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1886
                        self.match(SolidityParser.NL) 
                    self.state = 1891
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,259,self._ctx)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1892
                self.numberLiteral()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1893
                self.hexLiteral()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1894
                self.stringLiteral()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1895
                self.identifier()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1896
                self.match(SolidityParser.TypeKeyword)
                self.state = 1900
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,260,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1897
                        self.match(SolidityParser.NL) 
                    self.state = 1902
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,260,self._ctx)

                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1903
                self.match(SolidityParser.PayableKeyword)
                self.state = 1907
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,261,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1904
                        self.match(SolidityParser.NL) 
                    self.state = 1909
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,261,self._ctx)

                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1910
                self.tupleExpression()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1911
                self.typeName(0)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ExpressionContext,i)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_expressionList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpressionList" ):
                listener.enterExpressionList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpressionList" ):
                listener.exitExpressionList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpressionList" ):
                return visitor.visitExpressionList(self)
            else:
                return visitor.visitChildren(self)




    def expressionList(self):

        localctx = SolidityParser.ExpressionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_expressionList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1914
            self.expression(0)
            self.state = 1925
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==15:
                self.state = 1915
                self.match(SolidityParser.T__14)
                self.state = 1919
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1916
                    self.match(SolidityParser.NL)
                    self.state = 1921
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1922
                self.expression(0)
                self.state = 1927
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NameValueListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def nameValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.NameValueContext)
            else:
                return self.getTypedRuleContext(SolidityParser.NameValueContext,i)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_nameValueList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNameValueList" ):
                listener.enterNameValueList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNameValueList" ):
                listener.exitNameValueList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNameValueList" ):
                return visitor.visitNameValueList(self)
            else:
                return visitor.visitChildren(self)




    def nameValueList(self):

        localctx = SolidityParser.NameValueListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_nameValueList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1928
            self.nameValue()
            self.state = 1939
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,266,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1929
                    self.match(SolidityParser.T__14)
                    self.state = 1933
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 1930
                        self.match(SolidityParser.NL)
                        self.state = 1935
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1936
                    self.nameValue() 
                self.state = 1941
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,266,self._ctx)

            self.state = 1949
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==15:
                self.state = 1942
                self.match(SolidityParser.T__14)
                self.state = 1946
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1943
                    self.match(SolidityParser.NL)
                    self.state = 1948
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NameValueContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_nameValue

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNameValue" ):
                listener.enterNameValue(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNameValue" ):
                listener.exitNameValue(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNameValue" ):
                return visitor.visitNameValue(self)
            else:
                return visitor.visitChildren(self)




    def nameValue(self):

        localctx = SolidityParser.NameValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_nameValue)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1951
            self.identifier()
            self.state = 1952
            self.match(SolidityParser.T__69)
            self.state = 1956
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1953
                self.match(SolidityParser.NL)
                self.state = 1958
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1959
            self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionCallArgumentsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def nameValueList(self):
            return self.getTypedRuleContext(SolidityParser.NameValueListContext,0)


        def expressionList(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionCallArguments

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionCallArguments" ):
                listener.enterFunctionCallArguments(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionCallArguments" ):
                listener.exitFunctionCallArguments(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionCallArguments" ):
                return visitor.visitFunctionCallArguments(self)
            else:
                return visitor.visitChildren(self)




    def functionCallArguments(self):

        localctx = SolidityParser.FunctionCallArgumentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_functionCallArguments)
        self._la = 0 # Token type
        try:
            self.state = 1981
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [14]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1961
                self.match(SolidityParser.T__13)
                self.state = 1965
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1962
                    self.match(SolidityParser.NL)
                    self.state = 1967
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1969
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4612257764490616832) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971073) != 0):
                    self.state = 1968
                    self.nameValueList()


                self.state = 1971
                self.match(SolidityParser.T__15)
                self.state = 1975
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 1972
                    self.match(SolidityParser.NL)
                    self.state = 1977
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [5, 13, 22, 23, 24, 29, 30, 37, 41, 43, 45, 49, 62, 63, 64, 65, 66, 67, 68, 69, 71, 72, 95, 97, 98, 99, 100, 101, 102, 103, 104, 106, 113, 117, 122, 124, 125, 127, 128, 129]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1979
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 5)) & ~0x3f) == 0 and ((1 << (_la - 5)) & -144096148434845439) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & 2135005496493473805) != 0):
                    self.state = 1978
                    self.expressionList()


                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionCallContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def functionCallArguments(self):
            return self.getTypedRuleContext(SolidityParser.FunctionCallArgumentsContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_functionCall

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionCall" ):
                listener.enterFunctionCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionCall" ):
                listener.exitFunctionCall(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionCall" ):
                return visitor.visitFunctionCall(self)
            else:
                return visitor.visitChildren(self)




    def functionCall(self):

        localctx = SolidityParser.FunctionCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_functionCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1983
            self.expression(0)
            self.state = 1984
            self.match(SolidityParser.T__21)
            self.state = 1988
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 1985
                self.match(SolidityParser.NL)
                self.state = 1990
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1991
            self.functionCallArguments()
            self.state = 1992
            self.match(SolidityParser.T__22)
            self.state = 1996
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,276,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1993
                    self.match(SolidityParser.NL) 
                self.state = 1998
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,276,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyBlockContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def assemblyItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyItemContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyItemContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyBlock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyBlock" ):
                listener.enterAssemblyBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyBlock" ):
                listener.exitAssemblyBlock(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyBlock" ):
                return visitor.visitAssemblyBlock(self)
            else:
                return visitor.visitChildren(self)




    def assemblyBlock(self):

        localctx = SolidityParser.AssemblyBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_assemblyBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1999
            self.match(SolidityParser.T__13)
            self.state = 2003
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 2000
                self.match(SolidityParser.NL)
                self.state = 2005
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2009
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 5189844554211155968) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & -1438678597496733695) != 0):
                self.state = 2006
                self.assemblyItem()
                self.state = 2011
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2012
            self.match(SolidityParser.T__15)
            self.state = 2016
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 2013
                self.match(SolidityParser.NL)
                self.state = 2018
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyItemContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def assemblyLocalDefinition(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyLocalDefinitionContext,0)


        def assemblyAssignment(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyAssignmentContext,0)


        def assemblyStackAssignment(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyStackAssignmentContext,0)


        def labelDefinition(self):
            return self.getTypedRuleContext(SolidityParser.LabelDefinitionContext,0)


        def assemblySwitch(self):
            return self.getTypedRuleContext(SolidityParser.AssemblySwitchContext,0)


        def assemblyFunctionDefinition(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyFunctionDefinitionContext,0)


        def assemblyFor(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyForContext,0)


        def assemblyIf(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIfContext,0)


        def BreakKeyword(self):
            return self.getToken(SolidityParser.BreakKeyword, 0)

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def ContinueKeyword(self):
            return self.getToken(SolidityParser.ContinueKeyword, 0)

        def LeaveKeyword(self):
            return self.getToken(SolidityParser.LeaveKeyword, 0)

        def numberLiteral(self):
            return self.getTypedRuleContext(SolidityParser.NumberLiteralContext,0)


        def stringLiteral(self):
            return self.getTypedRuleContext(SolidityParser.StringLiteralContext,0)


        def hexLiteral(self):
            return self.getTypedRuleContext(SolidityParser.HexLiteralContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyItem

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyItem" ):
                listener.enterAssemblyItem(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyItem" ):
                listener.exitAssemblyItem(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyItem" ):
                return visitor.visitAssemblyItem(self)
            else:
                return visitor.visitChildren(self)




    def assemblyItem(self):

        localctx = SolidityParser.AssemblyItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_assemblyItem)
        self._la = 0 # Token type
        try:
            self.state = 2054
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,283,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2019
                self.identifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2020
                self.assemblyBlock()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2021
                self.assemblyExpression()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2022
                self.assemblyLocalDefinition()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2023
                self.assemblyAssignment()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 2024
                self.assemblyStackAssignment()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 2025
                self.labelDefinition()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 2026
                self.assemblySwitch()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 2027
                self.assemblyFunctionDefinition()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 2028
                self.assemblyFor()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 2029
                self.assemblyIf()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 2030
                self.match(SolidityParser.BreakKeyword)
                self.state = 2034
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2031
                    self.match(SolidityParser.NL)
                    self.state = 2036
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 2037
                self.match(SolidityParser.ContinueKeyword)
                self.state = 2041
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2038
                    self.match(SolidityParser.NL)
                    self.state = 2043
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 2044
                self.match(SolidityParser.LeaveKeyword)
                self.state = 2048
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2045
                    self.match(SolidityParser.NL)
                    self.state = 2050
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 2051
                self.numberLiteral()
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 2052
                self.stringLiteral()
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 2053
                self.hexLiteral()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyCall(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyCallContext,0)


        def assemblyLiteral(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyLiteralContext,0)


        def assemblyMember(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyMemberContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyExpression" ):
                listener.enterAssemblyExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyExpression" ):
                listener.exitAssemblyExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyExpression" ):
                return visitor.visitAssemblyExpression(self)
            else:
                return visitor.visitChildren(self)




    def assemblyExpression(self):

        localctx = SolidityParser.AssemblyExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_assemblyExpression)
        try:
            self.state = 2059
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,284,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2056
                self.assemblyCall()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2057
                self.assemblyLiteral()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2058
                self.assemblyMember()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyMemberContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyMember

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyMember" ):
                listener.enterAssemblyMember(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyMember" ):
                listener.exitAssemblyMember(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyMember" ):
                return visitor.visitAssemblyMember(self)
            else:
                return visitor.visitChildren(self)




    def assemblyMember(self):

        localctx = SolidityParser.AssemblyMemberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_assemblyMember)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2061
            self.identifier()
            self.state = 2062
            self.match(SolidityParser.T__43)
            self.state = 2066
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 2063
                self.match(SolidityParser.NL)
                self.state = 2068
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2069
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyCallContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def assemblyExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyCall

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyCall" ):
                listener.enterAssemblyCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyCall" ):
                listener.exitAssemblyCall(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyCall" ):
                return visitor.visitAssemblyCall(self)
            else:
                return visitor.visitChildren(self)




    def assemblyCall(self):

        localctx = SolidityParser.AssemblyCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_assemblyCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2093
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,289,self._ctx)
            if la_ == 1:
                self.state = 2071
                self.match(SolidityParser.T__58)
                self.state = 2075
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2072
                    self.match(SolidityParser.NL)
                    self.state = 2077
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2078
                self.match(SolidityParser.T__42)
                self.state = 2082
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2079
                    self.match(SolidityParser.NL)
                    self.state = 2084
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2085
                self.match(SolidityParser.T__65)
                self.state = 2089
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2086
                    self.match(SolidityParser.NL)
                    self.state = 2091
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 4:
                self.state = 2092
                self.identifier()
                pass


            self.state = 2125
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,295,self._ctx)
            if la_ == 1:
                self.state = 2095
                self.match(SolidityParser.T__21)
                self.state = 2099
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2096
                    self.match(SolidityParser.NL)
                    self.state = 2101
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2103
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 5188718516794040320) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & -1438757762371682303) != 0):
                    self.state = 2102
                    self.assemblyExpression()


                self.state = 2115
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==15:
                    self.state = 2105
                    self.match(SolidityParser.T__14)
                    self.state = 2109
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 2106
                        self.match(SolidityParser.NL)
                        self.state = 2111
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 2112
                    self.assemblyExpression()
                    self.state = 2117
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2118
                self.match(SolidityParser.T__22)
                self.state = 2122
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2119
                    self.match(SolidityParser.NL)
                    self.state = 2124
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyLocalDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyIdentifierOrList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierOrListContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyLocalDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyLocalDefinition" ):
                listener.enterAssemblyLocalDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyLocalDefinition" ):
                listener.exitAssemblyLocalDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyLocalDefinition" ):
                return visitor.visitAssemblyLocalDefinition(self)
            else:
                return visitor.visitChildren(self)




    def assemblyLocalDefinition(self):

        localctx = SolidityParser.AssemblyLocalDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_assemblyLocalDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2127
            self.match(SolidityParser.T__87)
            self.state = 2131
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 2128
                self.match(SolidityParser.NL)
                self.state = 2133
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2134
            self.assemblyIdentifierOrList()
            self.state = 2143
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==89:
                self.state = 2135
                self.match(SolidityParser.T__88)
                self.state = 2139
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2136
                    self.match(SolidityParser.NL)
                    self.state = 2141
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2142
                self.assemblyExpression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyAssignmentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyIdentifierOrList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierOrListContext,0)


        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyAssignment

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyAssignment" ):
                listener.enterAssemblyAssignment(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyAssignment" ):
                listener.exitAssemblyAssignment(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyAssignment" ):
                return visitor.visitAssemblyAssignment(self)
            else:
                return visitor.visitChildren(self)




    def assemblyAssignment(self):

        localctx = SolidityParser.AssemblyAssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_assemblyAssignment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2145
            self.assemblyIdentifierOrList()
            self.state = 2146
            self.match(SolidityParser.T__88)
            self.state = 2150
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 2147
                self.match(SolidityParser.NL)
                self.state = 2152
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2153
            self.assemblyExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyIdentifierOrListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def assemblyMember(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyMemberContext,0)


        def assemblyIdentifierList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierListContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyIdentifierOrList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyIdentifierOrList" ):
                listener.enterAssemblyIdentifierOrList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyIdentifierOrList" ):
                listener.exitAssemblyIdentifierOrList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyIdentifierOrList" ):
                return visitor.visitAssemblyIdentifierOrList(self)
            else:
                return visitor.visitChildren(self)




    def assemblyIdentifierOrList(self):

        localctx = SolidityParser.AssemblyIdentifierOrListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_assemblyIdentifierOrList)
        self._la = 0 # Token type
        try:
            self.state = 2173
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,302,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2155
                self.identifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2156
                self.assemblyMember()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2157
                self.assemblyIdentifierList()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2158
                self.match(SolidityParser.T__21)
                self.state = 2162
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2159
                    self.match(SolidityParser.NL)
                    self.state = 2164
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2165
                self.assemblyIdentifierList()
                self.state = 2166
                self.match(SolidityParser.T__22)
                self.state = 2170
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2167
                    self.match(SolidityParser.NL)
                    self.state = 2172
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyIdentifierListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyIdentifierList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyIdentifierList" ):
                listener.enterAssemblyIdentifierList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyIdentifierList" ):
                listener.exitAssemblyIdentifierList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyIdentifierList" ):
                return visitor.visitAssemblyIdentifierList(self)
            else:
                return visitor.visitChildren(self)




    def assemblyIdentifierList(self):

        localctx = SolidityParser.AssemblyIdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_assemblyIdentifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2175
            self.identifier()
            self.state = 2186
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==15:
                self.state = 2176
                self.match(SolidityParser.T__14)
                self.state = 2180
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2177
                    self.match(SolidityParser.NL)
                    self.state = 2182
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2183
                self.identifier()
                self.state = 2188
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyStackAssignmentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyStackAssignment

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyStackAssignment" ):
                listener.enterAssemblyStackAssignment(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyStackAssignment" ):
                listener.exitAssemblyStackAssignment(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyStackAssignment" ):
                return visitor.visitAssemblyStackAssignment(self)
            else:
                return visitor.visitChildren(self)




    def assemblyStackAssignment(self):

        localctx = SolidityParser.AssemblyStackAssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_assemblyStackAssignment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2189
            self.assemblyExpression()
            self.state = 2190
            self.match(SolidityParser.T__89)
            self.state = 2194
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 2191
                self.match(SolidityParser.NL)
                self.state = 2196
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2197
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LabelDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_labelDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLabelDefinition" ):
                listener.enterLabelDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLabelDefinition" ):
                listener.exitLabelDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLabelDefinition" ):
                return visitor.visitLabelDefinition(self)
            else:
                return visitor.visitChildren(self)




    def labelDefinition(self):

        localctx = SolidityParser.LabelDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_labelDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2199
            self.identifier()
            self.state = 2200
            self.match(SolidityParser.T__69)
            self.state = 2204
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 2201
                self.match(SolidityParser.NL)
                self.state = 2206
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblySwitchContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def assemblyCase(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyCaseContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyCaseContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblySwitch

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblySwitch" ):
                listener.enterAssemblySwitch(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblySwitch" ):
                listener.exitAssemblySwitch(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblySwitch" ):
                return visitor.visitAssemblySwitch(self)
            else:
                return visitor.visitChildren(self)




    def assemblySwitch(self):

        localctx = SolidityParser.AssemblySwitchContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_assemblySwitch)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2207
            self.match(SolidityParser.T__90)
            self.state = 2211
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 2208
                self.match(SolidityParser.NL)
                self.state = 2213
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2214
            self.assemblyExpression()
            self.state = 2218
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==92 or _la==93:
                self.state = 2215
                self.assemblyCase()
                self.state = 2220
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyCaseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyLiteral(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyLiteralContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyCase

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyCase" ):
                listener.enterAssemblyCase(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyCase" ):
                listener.exitAssemblyCase(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyCase" ):
                return visitor.visitAssemblyCase(self)
            else:
                return visitor.visitChildren(self)




    def assemblyCase(self):

        localctx = SolidityParser.AssemblyCaseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_assemblyCase)
        self._la = 0 # Token type
        try:
            self.state = 2239
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [92]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2221
                self.match(SolidityParser.T__91)
                self.state = 2225
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2222
                    self.match(SolidityParser.NL)
                    self.state = 2227
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2228
                self.assemblyLiteral()
                self.state = 2229
                self.assemblyBlock()
                pass
            elif token in [93]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2231
                self.match(SolidityParser.T__92)
                self.state = 2235
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2232
                    self.match(SolidityParser.NL)
                    self.state = 2237
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2238
                self.assemblyBlock()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyFunctionDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def assemblyIdentifierList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierListContext,0)


        def assemblyFunctionReturns(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyFunctionReturnsContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyFunctionDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyFunctionDefinition" ):
                listener.enterAssemblyFunctionDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyFunctionDefinition" ):
                listener.exitAssemblyFunctionDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyFunctionDefinition" ):
                return visitor.visitAssemblyFunctionDefinition(self)
            else:
                return visitor.visitChildren(self)




    def assemblyFunctionDefinition(self):

        localctx = SolidityParser.AssemblyFunctionDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_assemblyFunctionDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2241
            self.match(SolidityParser.T__36)
            self.state = 2245
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 2242
                self.match(SolidityParser.NL)
                self.state = 2247
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2248
            self.identifier()
            self.state = 2249
            self.match(SolidityParser.T__21)
            self.state = 2253
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 2250
                self.match(SolidityParser.NL)
                self.state = 2255
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2257
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4612257764490616832) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971073) != 0):
                self.state = 2256
                self.assemblyIdentifierList()


            self.state = 2259
            self.match(SolidityParser.T__22)
            self.state = 2263
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 2260
                self.match(SolidityParser.NL)
                self.state = 2265
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2267
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==94:
                self.state = 2266
                self.assemblyFunctionReturns()


            self.state = 2269
            self.assemblyBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyFunctionReturnsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyIdentifierList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierListContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyFunctionReturns

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyFunctionReturns" ):
                listener.enterAssemblyFunctionReturns(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyFunctionReturns" ):
                listener.exitAssemblyFunctionReturns(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyFunctionReturns" ):
                return visitor.visitAssemblyFunctionReturns(self)
            else:
                return visitor.visitChildren(self)




    def assemblyFunctionReturns(self):

        localctx = SolidityParser.AssemblyFunctionReturnsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_assemblyFunctionReturns)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2271
            self.match(SolidityParser.T__93)
            self.state = 2275
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 2272
                self.match(SolidityParser.NL)
                self.state = 2277
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2278
            self.assemblyIdentifierList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyForContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,i)


        def assemblyBlock(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyBlockContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,i)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyFor

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyFor" ):
                listener.enterAssemblyFor(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyFor" ):
                listener.exitAssemblyFor(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyFor" ):
                return visitor.visitAssemblyFor(self)
            else:
                return visitor.visitChildren(self)




    def assemblyFor(self):

        localctx = SolidityParser.AssemblyForContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_assemblyFor)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2280
            self.match(SolidityParser.T__25)
            self.state = 2284
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 2281
                self.match(SolidityParser.NL)
                self.state = 2286
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2289
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [14]:
                self.state = 2287
                self.assemblyBlock()
                pass
            elif token in [13, 24, 43, 49, 59, 62, 66, 95, 102, 103, 104, 106, 113, 117, 124, 125, 127, 128, 129]:
                self.state = 2288
                self.assemblyExpression()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 2291
            self.assemblyExpression()
            self.state = 2294
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [14]:
                self.state = 2292
                self.assemblyBlock()
                pass
            elif token in [13, 24, 43, 49, 59, 62, 66, 95, 102, 103, 104, 106, 113, 117, 124, 125, 127, 128, 129]:
                self.state = 2293
                self.assemblyExpression()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 2296
            self.assemblyBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyIfContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyIf

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyIf" ):
                listener.enterAssemblyIf(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyIf" ):
                listener.exitAssemblyIf(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyIf" ):
                return visitor.visitAssemblyIf(self)
            else:
                return visitor.visitChildren(self)




    def assemblyIf(self):

        localctx = SolidityParser.AssemblyIfContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_assemblyIf)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2298
            self.match(SolidityParser.T__49)
            self.state = 2302
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==131:
                self.state = 2299
                self.match(SolidityParser.NL)
                self.state = 2304
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2305
            self.assemblyExpression()
            self.state = 2306
            self.assemblyBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def stringLiteral(self):
            return self.getTypedRuleContext(SolidityParser.StringLiteralContext,0)


        def DecimalNumber(self):
            return self.getToken(SolidityParser.DecimalNumber, 0)

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def HexNumber(self):
            return self.getToken(SolidityParser.HexNumber, 0)

        def hexLiteral(self):
            return self.getTypedRuleContext(SolidityParser.HexLiteralContext,0)


        def BooleanLiteral(self):
            return self.getToken(SolidityParser.BooleanLiteral, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyLiteral

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyLiteral" ):
                listener.enterAssemblyLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyLiteral" ):
                listener.exitAssemblyLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyLiteral" ):
                return visitor.visitAssemblyLiteral(self)
            else:
                return visitor.visitChildren(self)




    def assemblyLiteral(self):

        localctx = SolidityParser.AssemblyLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_assemblyLiteral)
        self._la = 0 # Token type
        try:
            self.state = 2325
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [129]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2308
                self.stringLiteral()
                pass
            elif token in [103]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2309
                self.match(SolidityParser.DecimalNumber)
                self.state = 2313
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2310
                    self.match(SolidityParser.NL)
                    self.state = 2315
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [104]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2316
                self.match(SolidityParser.HexNumber)
                self.state = 2320
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2317
                    self.match(SolidityParser.NL)
                    self.state = 2322
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [106]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2323
                self.hexLiteral()
                pass
            elif token in [102]:
                self.enterOuterAlt(localctx, 5)
                self.state = 2324
                self.match(SolidityParser.BooleanLiteral)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TupleExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ExpressionContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_tupleExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTupleExpression" ):
                listener.enterTupleExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTupleExpression" ):
                listener.exitTupleExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTupleExpression" ):
                return visitor.visitTupleExpression(self)
            else:
                return visitor.visitChildren(self)




    def tupleExpression(self):

        localctx = SolidityParser.TupleExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_tupleExpression)
        self._la = 0 # Token type
        try:
            self.state = 2389
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [22]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2327
                self.match(SolidityParser.T__21)
                self.state = 2331
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2328
                    self.match(SolidityParser.NL)
                    self.state = 2333
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2335
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 5)) & ~0x3f) == 0 and ((1 << (_la - 5)) & -144096148434845439) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & 2135005496493473805) != 0):
                    self.state = 2334
                    self.expression(0)


                self.state = 2349
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==15:
                    self.state = 2337
                    self.match(SolidityParser.T__14)
                    self.state = 2341
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 2338
                        self.match(SolidityParser.NL)
                        self.state = 2343
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 2345
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if ((((_la - 5)) & ~0x3f) == 0 and ((1 << (_la - 5)) & -144096148434845439) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & 2135005496493473805) != 0):
                        self.state = 2344
                        self.expression(0)


                    self.state = 2351
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2352
                self.match(SolidityParser.T__22)
                self.state = 2356
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,330,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2353
                        self.match(SolidityParser.NL) 
                    self.state = 2358
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,330,self._ctx)

                pass
            elif token in [41]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2359
                self.match(SolidityParser.T__40)
                self.state = 2363
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2360
                    self.match(SolidityParser.NL)
                    self.state = 2365
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2380
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 5)) & ~0x3f) == 0 and ((1 << (_la - 5)) & -144096148434845439) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & 2135005496493473805) != 0):
                    self.state = 2366
                    self.expression(0)
                    self.state = 2377
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==15:
                        self.state = 2367
                        self.match(SolidityParser.T__14)
                        self.state = 2371
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==131:
                            self.state = 2368
                            self.match(SolidityParser.NL)
                            self.state = 2373
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 2374
                        self.expression(0)
                        self.state = 2379
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 2382
                self.match(SolidityParser.T__41)
                self.state = 2386
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,335,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2383
                        self.match(SolidityParser.NL) 
                    self.state = 2388
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,335,self._ctx)

                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NumberLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DecimalNumber(self):
            return self.getToken(SolidityParser.DecimalNumber, 0)

        def HexNumber(self):
            return self.getToken(SolidityParser.HexNumber, 0)

        def NumberUnit(self):
            return self.getToken(SolidityParser.NumberUnit, 0)

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_numberLiteral

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNumberLiteral" ):
                listener.enterNumberLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNumberLiteral" ):
                listener.exitNumberLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNumberLiteral" ):
                return visitor.visitNumberLiteral(self)
            else:
                return visitor.visitChildren(self)




    def numberLiteral(self):

        localctx = SolidityParser.NumberLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_numberLiteral)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2405
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [103]:
                self.state = 2391
                self.match(SolidityParser.DecimalNumber)
                self.state = 2395
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,337,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2392
                        self.match(SolidityParser.NL) 
                    self.state = 2397
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,337,self._ctx)

                pass
            elif token in [104]:
                self.state = 2398
                self.match(SolidityParser.HexNumber)
                self.state = 2402
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,338,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2399
                        self.match(SolidityParser.NL) 
                    self.state = 2404
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,338,self._ctx)

                pass
            else:
                raise NoViableAltException(self)

            self.state = 2414
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,341,self._ctx)
            if la_ == 1:
                self.state = 2407
                self.match(SolidityParser.NumberUnit)
                self.state = 2411
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,340,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2408
                        self.match(SolidityParser.NL) 
                    self.state = 2413
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,340,self._ctx)



        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ReceiveKeyword(self):
            return self.getToken(SolidityParser.ReceiveKeyword, 0)

        def GlobalKeyword(self):
            return self.getToken(SolidityParser.GlobalKeyword, 0)

        def ConstructorKeyword(self):
            return self.getToken(SolidityParser.ConstructorKeyword, 0)

        def PayableKeyword(self):
            return self.getToken(SolidityParser.PayableKeyword, 0)

        def LeaveKeyword(self):
            return self.getToken(SolidityParser.LeaveKeyword, 0)

        def Identifier(self):
            return self.getToken(SolidityParser.Identifier, 0)

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_identifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIdentifier" ):
                listener.enterIdentifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIdentifier" ):
                listener.exitIdentifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIdentifier" ):
                return visitor.visitIdentifier(self)
            else:
                return visitor.visitChildren(self)




    def identifier(self):

        localctx = SolidityParser.IdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_identifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2416
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 4612257764490616832) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 14499971073) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 2420
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,342,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2417
                    self.match(SolidityParser.NL) 
                self.state = 2422
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,342,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class HexLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def HexLiteralFragment(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.HexLiteralFragment)
            else:
                return self.getToken(SolidityParser.HexLiteralFragment, i)

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_hexLiteral

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterHexLiteral" ):
                listener.enterHexLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitHexLiteral" ):
                listener.exitHexLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitHexLiteral" ):
                return visitor.visitHexLiteral(self)
            else:
                return visitor.visitChildren(self)




    def hexLiteral(self):

        localctx = SolidityParser.HexLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_hexLiteral)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2430 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 2423
                    self.match(SolidityParser.HexLiteralFragment)
                    self.state = 2427
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,343,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 2424
                            self.match(SolidityParser.NL) 
                        self.state = 2429
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,343,self._ctx)


                else:
                    raise NoViableAltException(self)
                self.state = 2432 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,344,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OverrideSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def userDefinedTypeName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.UserDefinedTypeNameContext)
            else:
                return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_overrideSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOverrideSpecifier" ):
                listener.enterOverrideSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOverrideSpecifier" ):
                listener.exitOverrideSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOverrideSpecifier" ):
                return visitor.visitOverrideSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def overrideSpecifier(self):

        localctx = SolidityParser.OverrideSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_overrideSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2434
            self.match(SolidityParser.T__95)
            self.state = 2438
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,345,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2435
                    self.match(SolidityParser.NL) 
                self.state = 2440
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,345,self._ctx)

            self.state = 2469
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==22:
                self.state = 2441
                self.match(SolidityParser.T__21)
                self.state = 2445
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2442
                    self.match(SolidityParser.NL)
                    self.state = 2447
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2448
                self.userDefinedTypeName()
                self.state = 2459
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==15:
                    self.state = 2449
                    self.match(SolidityParser.T__14)
                    self.state = 2453
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==131:
                        self.state = 2450
                        self.match(SolidityParser.NL)
                        self.state = 2455
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 2456
                    self.userDefinedTypeName()
                    self.state = 2461
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2462
                self.match(SolidityParser.T__22)
                self.state = 2466
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,349,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2463
                        self.match(SolidityParser.NL) 
                    self.state = 2468
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,349,self._ctx)



        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StringLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def StringLiteralFragment(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.StringLiteralFragment)
            else:
                return self.getToken(SolidityParser.StringLiteralFragment, i)

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_stringLiteral

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStringLiteral" ):
                listener.enterStringLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStringLiteral" ):
                listener.exitStringLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStringLiteral" ):
                return visitor.visitStringLiteral(self)
            else:
                return visitor.visitChildren(self)




    def stringLiteral(self):

        localctx = SolidityParser.StringLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_stringLiteral)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2478 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 2471
                    self.match(SolidityParser.StringLiteralFragment)
                    self.state = 2475
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,351,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 2472
                            self.match(SolidityParser.NL) 
                        self.state = 2477
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,351,self._ctx)


                else:
                    raise NoViableAltException(self)
                self.state = 2480 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,352,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EosContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NL(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.NL)
            else:
                return self.getToken(SolidityParser.NL, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_eos

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEos" ):
                listener.enterEos(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEos" ):
                listener.exitEos(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEos" ):
                return visitor.visitEos(self)
            else:
                return visitor.visitChildren(self)




    def eos(self):

        localctx = SolidityParser.EosContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_eos)
        self._la = 0 # Token type
        try:
            self.state = 2500
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,356,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2485
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2482
                    self.match(SolidityParser.NL)
                    self.state = 2487
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2488
                self.match(SolidityParser.T__55)
                self.state = 2492
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==131:
                    self.state = 2489
                    self.match(SolidityParser.NL)
                    self.state = 2494
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2496 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 2495
                    self.match(SolidityParser.NL)
                    self.state = 2498 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==131):
                        break

                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[38] = self.typeName_sempred
        self._predicates[70] = self.expression_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def typeName_sempred(self, localctx:TypeNameContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 3)
         

    def expression_sempred(self, localctx:ExpressionContext, predIndex:int):
            if predIndex == 1:
                return self.precpred(self._ctx, 14)
         

            if predIndex == 2:
                return self.precpred(self._ctx, 13)
         

            if predIndex == 3:
                return self.precpred(self._ctx, 12)
         

            if predIndex == 4:
                return self.precpred(self._ctx, 11)
         

            if predIndex == 5:
                return self.precpred(self._ctx, 10)
         

            if predIndex == 6:
                return self.precpred(self._ctx, 9)
         

            if predIndex == 7:
                return self.precpred(self._ctx, 8)
         

            if predIndex == 8:
                return self.precpred(self._ctx, 7)
         

            if predIndex == 9:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 10:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 11:
                return self.precpred(self._ctx, 4)
         

            if predIndex == 12:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 13:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 14:
                return self.precpred(self._ctx, 27)
         

            if predIndex == 15:
                return self.precpred(self._ctx, 25)
         

            if predIndex == 16:
                return self.precpred(self._ctx, 24)
         

            if predIndex == 17:
                return self.precpred(self._ctx, 23)
         

            if predIndex == 18:
                return self.precpred(self._ctx, 22)
         

            if predIndex == 19:
                return self.precpred(self._ctx, 21)
         




